lowering: a self tail call becomes a loop

[simontreanor]

Dogfooding finding #6 (see #34), implementing the option you picked: lowering-only, no language change.

CPython has no TCE and caps the stack near 1000 frames, so an interactive loop written as recursion walks a stack it has no reason to build. The dogfooded game called setRecursionLimit 20000 at startup for exactly this.

A direct, saturated self tail call now lowers to:

def turn(state, deck):          # let turn state deck =
    while True:                 #   if over state then state
        if over(state):         #   else turn (step state) (rest deck)
            return state
        state, deck = (step(state), rest(deck))
        continue

Several parameters rebind simultaneously from one tuple, so an argument still reads the previous iteration's values, exactly as the call it replaces evaluated its arguments before entering.

Why it is small. The pass runs on the lowered body rather than the Pyfun AST. lower_return emits a Return only in tail position, so "tail call" is just "a Return whose value calls our own name at our own arity", and the tail-position walk is a walk over statements that already exist. No new notion of tail position was needed.

The four preconditions, each falling back to the ordinary recursive def (always correct, merely stack-bound):

1. the body must not rebind the function's own name (a shadowing let would make the loop jump where the program meant to call);
2. it must not be a generator or coroutine (return in a generator raises StopIteration with a value; an async tail call is an await);
3. the walk does not descend into a for (a continue there belongs to the for) or a try (looping inside it would put every later iteration under a handler that covered one call);
4. no nested function may mention a name this frame binds.

Number 4 is the one that makes this sound, and it is worth the review time. The loop reuses one cell per parameter where recursion gave each frame its own, so a closure that outlives its iteration would see the final value rather than the one it was made with. let collect n acc = … collect (n - 1) (List.concat acc [fun k -> n]) must therefore stay recursive, and there is an end-to-end test asserting the closures still yield [3, 2, 1] rather than trusting the reasoning.

Merge-order note: this branch adds PyStmt::UnpackAssign to the Python IR, and so does #38 (which needs it for destructuring parameters). Both are off main rather than stacked, so whichever merges second will hit a small conflict: an enum variant and its emitter arm, added identically in both.

Tests: 8 in tests/compile.rs (loop shape, simultaneous rebinding, a tail call in a match arm, non-tail left alone, mutual recursion left alone, the closure guard, plus two e2e: 50k/100k-deep recursion that only completes as a loop, and the closure semantics above). Full suite, clippy and fmt clean. Documented as DESIGN §5.4 with mechanics in INTERNALS.