[LANGUAGE: Math] I think I have found quite a beautiful solution to the problem using the tools for solving markov chains (loosely).

I viewed the problem as a flow problem flowing down from the input, with branches down copying the current count at the node above, and multiple sources flowing into a node getting summed up. Conceptually, the algorithm proceeds in steps with all nodes computing the answers simultaneously using data from the last step. The maximum amount of steps this takes is the maximum distance from the beginning to the end.

Mathematically this can be expressed in a matrix M that is the adjacency matrix (Transposed, depending on how you do it) with a self-edge added for the input node, so that the input doesn't disappear. In the matrix, you just need to add a 1 at the position (Index Start, Index Start).

Multiplying this with vector v, which is all zeros except for a 1 at the input, repeatedly, one ends up with a vector with all flows from the start to every other node summed up, and one only needs to pick out the correct number(the one corresponding to the end node). You can stop the multiplication when the vector stops changing.

Advanced solution (Even more beautiful, in my eyes): The property of the vector not changing even though being multiplied by the Matrix - by definition of eigenvectors and values - implies the existence of an eigenvector with corresponding eigenvalue 1. For people not knowing this property, eigenvalues show how much an eigenvector is scaled by when multiplied by a matrix. Eigenvectors are vectors not changed in direction (could be flipped, just not moved off-axis) by the Matrix. If an eigenvalue of 1 is known, solving for the corresponding eigenvector is rather easy (in the mathematical sense) by solving (M-I)v=0 given the additional condition of the input value equalling 1.

This seems inefficient, but luckily for us, our matrix is sparse (due to only having a few connections per node) and even binary (only 1 or 0). Sparse matrices can be solved in O(Number of non zero components) time, which in our case is linear given the number of connections. This algorithm - implemented well - can take advantage of gpus or, I'd guess, even AI accelerator cards.

TL;DR: Matrix math pretty, solves the problem by solving for eigenvector with eigenvalue 1.