a log-space reduction
A reduction is a translator that turns one problem into another so an answer to the second hands you the answer to the first. But the translator itself uses some resources, and to compare very low-memory classes we need a translator that is itself memory-thrifty. A log-space reduction is a translation that can be computed using only O(log n) work memory. It is the gentle scalpel you use when studying L and NL, fine enough not to overpower the very classes you are dissecting.
Formally, a log-space reduction from language A to B is a function f, computable by a deterministic Turing machine that uses O(log n) work-tape space, such that w is in A if and only if f(w) is in B. A subtlety: the output f(w) may itself be long (up to polynomial length), longer than the log-space work tape, so the machine writes it to a separate write-only output tape it cannot read back, producing the answer left to right while only ever remembering a few pointers. This is exactly the kind of mild reduction that defines NL-completeness and L-hardness.
Why insist on log space rather than the more familiar polynomial-time reduction? Because to separate classes as small as L and NL, the reduction must be weaker than the classes themselves. A polynomial-time reduction can do far more than a log-space machine, so using it would let the translation smuggle in power and would make even trivial problems look complete; the distinctions we care about would collapse. Two facts keep the theory clean: log-space reductions compose (chaining two stays in log space, which is not obvious and takes a clever argument), and L and NL are both closed under them, so completeness is well behaved.
Reducing 2-coloring to PATH in log space: you scan the graph's edge list and emit, for the reachability instance, an edge for each constraint, writing output symbols one at a time to the output tape while keeping only the current vertex indices in work memory. You never need to hold the whole output, just a few O(log n)-bit pointers.
A log-space reduction writes a possibly-long output left to right, keeping only O(log n) bits of working state.
Log-space reductions compose (their chaining stays in log space, by a nontrivial argument), which is what makes NL-completeness consistent. Using polynomial-time reductions instead would be too coarse to separate L from NL.