As it turns out, we can't show that $\mathrm{PATH}$ is in $\mathbf L$, though that is the most common belief. Just like in the case of $\mathbf P$ and $\mathbf{NP}$, we don't know whether $\mathbf L$ is equal to $\mathbf{NL}$. And in the same vein, we will attempt to characterize the languages that define $\mathbf{NL}$ by defining the notion of $\mathbf{NL}$-completeness.
A problem arises when we try to apply the notion of reducibility that we've used for $\mathbf{NP}$ and $\mathbf{PSPACE}$. It turns out that every language in $\mathbf{NL}$ is solvable in polynomial time, which makes a polynomial time reduction too powerful for our purposes. Again, we need to consider a more restrictive notion of reducibility for logarithmic space.
A log space transducer is a Turing machine with a read-only input tape, a write-only output tape, and a read/write work tape. The head on the output tape cannot move leftward so it cannot read what it has written. The work tape may only contain $O(\log n)$ symbols. A log space transducer $M$ computes a function $f:\Sigma^* \to \Sigma^*$, where $f(w)$ is the string remaining on the output tape after $M$ halts when it is started with $w$ on its input tape. We call $f$ a log space computable function.
A language $A$ is logspace reducible to a language $B$ ($A \leq_L B$) if $A$ is mapping reducible to $B$ by means of a logspace computable function $f$.
A language $B$ is $\mathbf{NL}$-complete if $B \in \mathbf{NL}$ and for every $A \in \mathbf{NL}$, $A$ is logspace reducible to $B$.
Theorem. If $A \leq_L B$ and $B \in \mathbf L$, then $A \in \mathbf L$.
Proof. This seems very obvious, in the same vein as mapping reducibility or polynomial time reducibility. However, we run into a problem if we try directly applying the same technique: the output $f(w)$ may not have logarithmic size.
The solution to this is to construct the algorithm for $A$ so that the algorithm for $B$ only requests one symbol of $f(w)$ at a time, rather than computing the entirety of $f(w)$ and storing it. We can do this by keeping track of how much of $f(w)$ the algorithm for $B$ has read. Then if the algorithm requests the $i$th symbol of $f(w)$, we compute $f(w)$ from the beginning but write only the $i$th symbol. Thus, only one symbol only needs to be stored at a time. $$\tag*{$\Box$}$$
Corollary. If any $\mathbf{NL}$-complete language is in $\mathbf L$, then $\mathbf L = \mathbf{NL}$.
So our notion and definition of $\mathbf{NL}$-completeness gives us the same property as with $\mathbf{NP}$-completeness. That is, we have a very simple way to show that $\mathbf L = \mathbf{NL}$: simply show that there's a deterministic algorithm in logspace for some problem that's $\mathbf{NL}$-complete. But first, we need at least one $\mathbf{NL}$-complete problem to do that.
Theorem. $\mathrm{PATH}$ is $\mathbf{NL}$-complete.
Proof. We already know that $\mathrm{PATH}$ is in $\mathbf{NL}$, so we only need to show hardness. Let $M$ be a nondeterministic Turing machine that decides a language $A$ in $O(\log n)$ space. Given an input word $w$, we will construct $\langle G,s,t \rangle$ such that $G$ is a graph that contains a path from $s$ to $t$ if and only if $M$ accepts $w$.
We define the vertices of $G$ to be the configurations of $M$ on $w$, where $(c_1,c_2)$ is an edge in $G$ if the configuration $c_2$ is reachable from the configuration $c_1$ on a transition defined by $M$. We set $s$ to be the starting configuration $c_{start}$ and $t$ to be the accepting configuration $c_{accept}$. Thus, there is a path from $s$ to $t$ if and only if $M$ accepts $w$.
Now, we describe the construction and show that it is computable in logarithmic space. Recall that a description of a graph is just a list of its vertices and edges. We begin by writing out every vertex of $G$. Since a vertex is just a configuration of $M$, a vertex clearly has size logarithmic in the length of $w$. So the transducer just goes through all strings of length $c \log n$ for some constant $c$ and checks whether the string is a legal configuration. Those that are get added to the output.
We can do something similar with the edges. Recall that we can test whether a configuration follows directly from another by examining the area around the tape heads and ensuring the rest of the configuration is the same. Since the configurations both have size logarithmic in the size of $w$, the size of both will use $O(\log n)$ space. Then we simply test all pairs of configurations $c_1$ and $c_2$ and output those that follow from legal transitions of $M$. $$\tag*{$\Box$}$$
Corollary. $\mathbf{NL} \subseteq \mathbf P$.
Proof. We just showed that any language in $\mathbf{NL}$ is logspace reducible to $\mathrm{PATH}$. Recall that a TM that uses $f(n)$ space will run in time $n2^{O(f(n))}$. Therefore, any logspace transducer will run in polynomial time. Then any language in $\mathbf{NL}$ is polynomial time reducible to $\mathrm{PATH}$, which is in $\mathbf P$. $$\tag*{$\Box$}$$