`optimize_implicit_jump` already flips a tail guard whose body is a single
bare `return`, but not one whose body is a block ending in `return`, since
`is_jump_statement` only unwraps single-statement blocks. Extend the
function-body-tail case to also accept `if (c) { X; return } REST`, rewriting
it to `if (c) { X } else { REST }`: the bare `return` makes REST reachable
only when `c` is false, so it moves into a new `else`.

The rewrite keeps the test polarity (a non-empty consequent gives a real
`else` to fill). Like the jump path, it re-minimizes the `else` body and re-runs
`try_minimize_if` inline, so both branches collapse into a conditional/logical
expression in the same pass once they reduce to expression statements
(`if (x) { foo(); return } bar()` => `x ? foo() : bar()`). Because the
re-minimize itself contains this arm, a whole chain of guards folds
innermost-first in a single pass — `if(a){x();return} if(b){y();return} z()`
becomes `a ? x() : b ? y() : z()` in one iteration rather than one guard per
iteration, which avoids an extra global fixed-point pass and the throwaway
intermediate block a deferred fold would allocate.

That single-pass fold recurses once per guard, and a flat guard chain is not
bounded by parse nesting, so `GUARD_INVERSION_MAX_DEPTH` caps the recursion
(threaded through `minimize_statements`); past it the arm falls back to the
deferred wrap so a pathologically long generated chain can't overflow the
stack. The cap is far above any real chain, so real fixtures fold identically.

Gated behind `options().sequences` like the jump path it extends, so DCE mode
(sequences off) is unaffected. REST and any existing alternate move into a
block, so the same `statement_cares_about_scope` guard bails when they declare
bindings the test could observe (a hoisted `function` the test calls, a
surviving lexical binding). Single-statement branches skip the wrapping block.
All minsize fixtures stay equal-or-smaller.