We can represent connections between platforms using a graph. The nodes of our graph will represent platforms and the edges of our graph will represent direct connections between platforms.
We can represent this graph using an adjacency matrix, that is, a matrix whose indices represent our nodes and which uses 0 or 1 to represent whether there's a direct connection between them.
Here's an illustration:

(Note that platforms are directly connected to themselves.)
In code, we can use a list of lists to represent this final matrix.
So, to build a model of the direct connections between platforms, we can construct a list of lists in the following way (using pseudo-code):
var connection_matrix = []
for platform_1 in platforms:
var submatrix = []
for platform_2 in platforms:
if platform_1.is_directly_connected_to(platform_2):
submatrix[platform_2] = 1 # 1 represents an edge on the graph, that is, a connection between platforms
else:
submatrix[platform_2] = 0 # 0 represents absence of an edge, that is, no connection between platforms
connection_matrix[platform_1] = submatrix
The only tricky thing here is constructing the is_directly_connected_to()
function. You can either use the collision resources built into your engine to determine if two platforms are touching, or, use any number of algorithms for determining it two rectangles intersect.
Once we have this graph of the connections between our platforms, we can use one of many algorithms to determine if a path exist between two nodes in the graph.
Alternatively, you can represent the graph using a dictionary-type data structure whose keys are platforms and whose values are lists of platforms, those directly connected to the keys.
Here's an illustration:

Constructing this dictionary representation is easy:
var connection_dictionary = []
for platform_1 in platforms:
var direct_connection_list = []
for platform_2 in platforms:
if platform_1.is_directly_connected_to(platform_2):
direct_connection_list.append(platform_2)
connection_dictionary[platform_1] = direct_connection_list
Once we have this graph of the direct connections between our platforms, we can use the following depth-first search algorithm to determine if there's a path between any two nodes in the graph.
def find_path(graph, start, end, path=[]):
path = path + [start]
if start == end:
return path
if not graph.has_key(start):
return None
for node in graph[start]:
if node not in path:
newpath = find_path(graph, node, end, path)
if newpath: return newpath
return None
(This algorithm is from the Python docs, but it can be adapted to other languages.)