Using UUIDs to execute functions

I found a solution. It's not very efficient, but it works and I'm sure you can come up with some way to improve it.
Feel free to ask me, if you don't understand something or need more help. :D

First of all, just inserting a stored value into a selector like you suggested ("/execute as @e[nbt={UUID:[ -somehow insert stored UUID here- ]}]") is not possible (to my knowledge).

Now to the solution I found: I first tried storing the UUID using '/execute store result storage', but I came across a problem that was similar to yours: While you needed a unique tag for each player, that method would need a unique storage for each player.
Then I noticed, that the UUID in the NBT of each entity basically is just an array of 4 integers. Since it's just integers, they can be stored in a normal scoreboard, which automatically creates a unique position for each entity that is given a score. Knowing that I added 4 scoreboards for the 4 integers that the UUID consists of:

scoreboard objectives add linkedUUID0 dummy
scoreboard objectives add linkedUUID1 dummy
scoreboard objectives add linkedUUID2 dummy
scoreboard objectives add linkedUUID3 dummy

These are named linkedUUID, because for each player they store the UUID of the entity that the players is linked to (=> wants to teleport to). I needed a way to store the UUID values in these scoreboards and came up with the following commands, which store the 4 UUID values of the nearest entity (@e; the distance=0.01.. is there to make sure it doesn't the select the player itself) in the linkedUUID score of the player that wants to be teleported to that entity later on (@p). Of course you can modify the selectors depending on what you need.

execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @p linkedUUID0 run data get entity @s UUID[​0]
execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @p linkedUUID1 run data get entity @s UUID[​1]
execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @p linkedUUID2 run data get entity @s UUID[​2]
execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @p linkedUUID3 run data get entity @s UUID[​3]

Because a player can only have 1 score your condition "A player in this datapack cannot select multiple entities at once. Only one at a time." is automatically met. Now I had scoreboards telling me what UUID a player wants to teleport to, but I needed 4 more scoreboards, which for the linked entities store their own UUID, so I can compare them and find the one to teleport to later:

scoreboard objectives add UUID0 dummy
scoreboard objectives add UUID1 dummy
scoreboard objectives add UUID2 dummy
scoreboard objectives add UUID3 dummy

Then the entity that is beeing linked to a player needs to store its own UUID to these UUID scoreboards. These commands should be executed simultaneously with the commands that store the linkedUUID to a player score:

execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @s UUID0 run data get entity @s UUID[​0]
execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @s UUID1 run data get entity @s UUID[​1]
execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @s UUID2 run data get entity @s UUID[​2]
execute at @p as @e[​limit=1,distance=0.01..,sort=nearest] store result score @s UUID3 run data get entity @s UUID[​3]

Finally, I just needed a way to teleport the player to the entity that matches the stored UUID. I just execute as every entity (@e) , if all its UUID scores (its own UUID) match the linkedUUID scores of the player that wants to teleport (@p):

execute at @p as @e[​distance=0.01..] if score @s UUID0 = @p linkedUUID0 if score @s UUID1 = @p linkedUUID1 if score @s UUID2 = @p linkedUUID2 if score @s UUID3 = @p linkedUUID3 run tp @p @s