To elaborate on the above:
My first thought in those messages, was a purely hypothetical idea about using NL's "predict the future" code (which is based on simulating a lemming's actions; generally used for skill shadows, but also occasionally used in physics too), to terminate the ascender if it will reach the 6 pixel maximum distance without finding a spot it can transitition back to a walker. This has to be ruled out in practice due to that the simulation code is only designed to simulate a single lemming at a time (plus passive effects, eg. blocker fields, from other lemmings), but this case - as it relies on other lemmings adding / removing terrain while the lemming is ascending to trigger it - would require simulating multiple. Aside from the code not supporting that, the performance impact of this would be very significant on any frame where an ascender is active (or even being simulated, during eg. projection shadows). This approach therefore must be ruled out.
Next idea is, if an ascender fails to ascend (and thus transitions to a faller), give this faller a special property where it will ignore solid terrain until it has detected at least one pixel of empty space (or, by implication, fallen back to where it started ascending from). I don't like this; it's an ugly edge case behavior. A bit less of an issue if we introduce it through a seperate state (like a "descender" rather than being a faller), but that would cause issues for custom lemming sprites and be a pain to implement, all for a tiny edge case.
After this, the possibility of simply accepting this outcome is suggested; it would be the kind of behavior that's discouraged in level design, but a concern is that the outcome could still arise unintentionally when stacking inside a 4-pixel tunnel - a lemming arriving at the might time may end up stuck in the ceiling, or stepping up through it if it's thin ehough (ie: total distance from the floor to the *top* of the ceiling is 12 pixels or less), even if the level designer didn't intend or even anticipate it.
One last thought that came to mind later, was to have an edge case rule where a failed ascender is immediately moved downwards to the nearest pixel of empty space (subject to not moving below where he started from). This would feel a bit "jumpy" in some cases, and it is an edge case, but it's a relatively contained one and may be the best way to deal with this problem.