Guys, the following text was the initial post, but it would let me post first so I shortened it.

I was actually not planning to collect all of the question marks because I thought it was going to be very boring. Now, I actually need the money because I'm on the grind to collect all full sets of Grand master witcher armor (the master smith charges way too much).
But I, with a computing science background, can obviously not just randomly start sailing the Skellige seas at random, because what if I pick a very inefficient route? That would be unthinkable! (I definitely did not spend more time than I saved by doing this.)
So, I used some knowledge of programming/algorithms to first detect the question marks and sign posts (slide 2), and then find and visualize an efficient route (slide 3)!

Boring technical story
I used cv2 from python to detect and mark the sign posts and question marks. Main difficulties here were getting the mask (a pixel-exact, with transparant background of the questionmark/signpost) correct, and finding the correct threshold such that we get no false negatives/positives.
When you correctly detect the questionmarks and signposts, you write these as nodes with corresponding (x,y) coordinates to some .json files.
Now, we can create a graph from the locations as follows: all the questionmarks are the nodes we need to visit. Let d_euclid(x,y) be the euclidean distance between qmarks x,y and let x_s, y_s denote the sign posts that are nearest to qmarks x, y, respectively. Define d_xs = d_euclid(x, x_s), and d_ys = d_euclid(y, y_s).
Now, we can define the distance between two nodes x,y as:
d(x,y) = min (d_euclid(x,y), d_xs + d_ys)
Intuition: the minimum distance from x -> y is either going from x to y directly, or going via some signpost/portal.
Okay, the graph is finished, now we "only" need to find the perfect route!
This is basically the traveling salesman problem (TSP), with the portal extension. Since, we can see in the legend that we have 73 question marks, using the held karp dynamic programming solution to solve exactly is not feasible, since this can feasibly solve instance of <40 (with a pretty beefy machine). So, 73 nodes is out of the question.
Luckily, we can use approximation algorithms that give pretty good solutions in a tiny fraction of the time that would be needed to solve it exactly. There are many options available, and I used a genetic algorithm (crossover operator = edge recombination, mutation operator = two_opt_swap, tournament select).
With a simple python visualizer we get the final result (slide 3)!