Your problem can be formulated as a maximum flow algorithm. A description of the problem and two algorithms for its solution are given in chapter 26 of "Introduction to Algorithms" by Cormen, Leiserson, Rivest, and Stein. You should read the first section of the chapter to understand my remarks.
The problem is not exactly a network flow problem as it stands, but we can easily modify it to put it into that form. First, we notice that a flow network is a digraph (directed graph), and the given graph is not directed. We modify the given network by replacing each edge, that is each line segment between two dots, by two directed edges, one in each direction. It is unnecessary to do this with the pads, since we don't want any flow into the pads. For the segments incident on the pads, just direct the edge away from the pad. (I would simply delete the pads that are already escaped from the graph.) Furthermore, we don't want any flow out of the red dots, so instead of replacing the segments incident on them by two edges, simply direct the segments into the red dots.
The next problem is that a flow network has a single source and a single sink, whereas our network has several of each. We add a "super-source" with an edge to each pad, and a "super-sink" with and edge from each red dot.
The third deficiency is that edges in a flow network are capacitated. We easily deal with this by giving each edge a capacity of $1$.
Now, the network we have constructed still has problems. We have introduced what the authors call "anti-parallel" edges, that is edges between the same pair of nodes, but in opposite directions. The authors explain how to deal with this in the paragraph starting at the bottom of page 711.
We have one final problem. Many of the nodes have multiple incoming and outgoing edges. It is possible for there to be a total flow of more than $1$ through such a node, which would mean that we have crossing paths. To obviate this, replace each such node $v$ by two nodes, say $v_I$ and $v_O$. All the incoming edges go to $v_I$ instead of $v$ and all the outgoing edges leave from $v_I$ instead of $v$. Finally there is a single edge, of capacity $1$ from $v_I$ to $v_O$. It is clear that there will be no more than one path through the new "node".
Once a maximum flow is found, the edges with a flow of $1$ in them give the desired paths, once they are translated back to the original network. While the modified network may sound complicated, and would be difficult to draw, I think it would be straight-forward to program. Translation back to the original network shouldn't present a problem.
Now, which max-flow algorithm should you actually use? In general, the push-relabel algorithms described in section 26.4 are the fastest, and are no harder to implement than the Ford-Fulkerson type algorithms, though they are harder to understand intuitively. (If you read the section, the authors try to give an intuitive explanation on page 737. The explanation makes no sense, and I would advise you to ignore it.) Ordinarily, I would opt for push-relabel, but in this instance, I think Edmonds-Karp algorithm described on page 727 might be preferable. The issue is that newtork flow algorithms are guaranteed to find a way to escape all the pads, if such a way exists, but they aren't guaranteed to find the simplest paths, whatever "simplest" means. Edmonds-Karp uses breadth-first search, and should find short paths.
From a programming standpoint, the major effort will surely be constructing the modified network, and in translating the answer back into terms of the original network. You can plug in one of the flow algorithms and see if it works satisfactorily. If not, plug in the other one.
Since all edges have capacity $1$, it's possible that some specialized algorithm exists that would be more efficient than a generic max-flow algorithm, but as a practical matter, I'd prefer using a tried-and-true method to developing a new one, unless the old method is too inefficient. Given the sizes of your networks, I don't think efficiency will be a problem.
I found an old C++ program of mine that implements push-relabel. It was probably written for a class, and I doubt it's production-quality code, but if you think it would be of use to you, I'd be glad to put it on github for you.
