What is a “temporal” or “timelike” logical error in the surface code?
An example of an undetectable timelike error is a stabilizer measurement being consistently wrong. For example, when you initialize your data qubits to be $|0\rangle$, all the X stabilizer measurements project randomly into their +1 or -1 eigenspaces. If one of the X stabilizers happens to project into its -1 eigenspace, but your measurements of that stabilizer keep failing and reporting that it's in its +1 eigenspace, that's an undetectable timelike error.
I find it difficult to appreciate the consequence of such error, either in a lattice surgery circuit, or in an identity circuit without computation.
You're correct that an undetectable timelike error can't hurt a typical identity circuit. However, this is only because identity circuits don't move the logical observable around.
Even more trickily, the timelike boundaries of an identity circuit in a memory experiment have a boundary type (X or Z) matching the type of the observable you want to measure. So errors of the opposite type (the type that can invert the observable you are measuring) can't terminate on those boundaries. So in a memory experiment there are no undetectable purely timelike errors that invert the logical observable you are measuring.
Problems only arise when the timelike boundaries are not of the same type as the observable you are tracking. This necessarily means the observable is partially spacelike. It has to move to the side because it can't terminate on a boundary of the opposite type. Which allows timelike errors to pierce it:
Can anyone elaborate why a bottom-to-top path is an issue, either in a lattice surgery circuit, or in an identity circuit without computation?
Computations often involve moving logical qubits around. For example, you might move a logical qubit from a storage area to a processing area. You do this by moving the X and Z logical observables defining the logical qubit. You move the observables by taking advantage of the fact that you have measured local X and Z stabilizers, which you can multiply into the corresponding logical observable to compute the slightly-moved observable that has been moved over the stabilizer at that location.
To be clear: there's not really anything moving on the quantum computer. You're just changing some tracking information in the classical control system. But you have to update the tracking information correctly.
You need to compute the products of all of the stabilizers in the area you want to move the observable across, because this tells you what the sign on the new tracked observable should be compared to the sign of the old tracked observable.
If there is a timelike error crossing through the area you move an observable over, then one of the stabilizers in that area has the wrong sign. When you multiply it into the area product while moving the observable over the stabilizer, you end up thinking the observable's sign is the opposite of what it should be. The observable-after-movement will not be equal to the observable-before-movement. And everything breaks. The logical qubit you are tracking now includes a Pauli error.
In summary: tracking logical qubits and operations often involves computing products of stabilizers in an area. Timelike errors negate stabilizer signs, breaking the tracking.
And, of course, real errors are often complicated combinations of spacelike and timelike errors with tons of symptoms that are just misleading enough that the decoder miscategorizes it.