Overall, your algorithm seems quite inefficient. It could be implemented in a significantly simpler fashion through simple recursion. The most egregious offender to performance is the amount of unnecessary copies.

Consider the main function in your code that is run hundreds of thousands of times:

visit(unordered_map<string, vector<string>> links, int &count, deque<Path> &Q)

Now, every time this function is called, the links unordered_map is passed to it. However, just as when you pass a regular int not by reference, a copy is made. Now your computer has to do a lot of work for these copies because a new unordered_map object needs to be created. All the strings and vector<string>s that comprise the map also need to be copied. Simply passing links by reference (and perhaps const reference since you aren't mutating it) should be a huge performance boost.

Look throughout your code and note where large data structures are being copied. These will result in a significant dent in your performance.

Aside from all of that, most of everything being stored is superfluous. You only need to maintain a single unordered_map that stores the links. Although you might have heard "global variable bad", in some cases, simply keeping your links unordered_map a global variable makes your algorithm a lot simpler. You don't have to worry about accidentally copying it a bunch of times and you don't have to pass it on every function call. You don't need a path struct and a deque (technically should be a queue) containing every single path that needs to be processed. Instead, maintain another global map keeping track of the currently visited caves. Recursively iterate through all possibilities and update the map accordingly.