Fix compiled generator/async-generator try/catch routing (#628, #632); lock #617, #543

[nickna]

Summary

Fixes a cluster of compiled-mode generator / async-generator try/catch bugs, all in the flag-based state-machine emission used when a yield/await crosses a protected region. The interpreter already handled every case; these bring compiled mode to parity with Node.

Issue	Status	Mode
#632 — a throw/rethrow from inside a catch/finally body isn't caught by an enclosing flag-based try	Fixed	sync + async
#628 — throwing/rejecting null/undefined into a flag-based try skips the catch	Fixed	async (the analog of #619)
#617 — a rejected await inside a try isn't caught by that try's catch	Already fixed on main; locked with tests	both
#543 — instanceof TypeError is false for an error caught inside a compiled generator body	Already fixed on main (compiled); locked with tests	compiled

#632 — handler-body throw routing (the substantive fix)

EmitThrow routed a handler-body throw only through enclosing finally frames and then did a real IL throw, which bypasses an outer flag-based try's caughtException/present flag — so the outer catch never ran and the exception escaped MoveNext/MoveNextAsync.

The fix routes the value into the enclosing flag-based try's capture local + present flag and branches to its cleanup, running the finally(s) strictly inside that try first — a new EmitThrowIntoEnclosingTry, the catch-side analog of the existing return/throw finally routing.

• The enclosing try is the one already tracked by _tryBodyContext (sync) / _currentTryExceptionLocal et al. (async): these are saved before a try body and restored before its catch/finally, so while emitting a handler they identify the enclosing try.
• A new ScopeDepth (= _exitScopes.Count at try-body start) + FinallyFramesInside computes the intervening-finally chain correctly even when the enclosing try has no finally of its own (so no stack marker).
• Applied at three propagation sites per emitter: the lexical EmitThrow handler case, the external it.throw() injection (EmitRoutedThrow), and the catch-less post-finally rethrow (an uncaught exception leaving a try/finally must reach an enclosing flag-based catch, not escape the state machine).
• Chain-empty → store directly; chain-nonempty (a finally may yield/await) → hold the value in <>pendingException across the finallys and move it via a routing terminal.

#628 — present-flag gate (async analog of #619)

A thrown/rejected null/undefined captures as a null CLR reference, which the old value-nullness Brfalse gate misread as "no exception". Ported the dedicated exceptionPresentLocal boolean gate (catch gate, segment-skip, post-finally rethrow) into AsyncGeneratorMoveNextEmitter; the #617 await-rejection routing now sets it too.

#617 / #543 — already fixed, now locked

Both behave correctly on main but the issues were never closed and lacked targeted coverage. Added regression tests (new GeneratorErrorIdentityTests for #543; the compiled re-entrancy test now asserts instanceof TypeError in-body) and updated the stale #543 deferral comment.

Gaps found and filed (out of scope here)

• Compiled generator: a real exception escaping a nested real-IL try/catch inside a flag-based catch/finally body is not caught by an enclosing flag-based try #675 — a real exception escaping a nested real-IL try/catch inside a flag-based catch body still escapes an enclosing flag-based try (a distinct mechanism: an exception already in flight, vs. a direct throw statement, which this PR fixes). Needs catch/finally bodies wrapped in capture-and-route sync segments.
• Interpreter: property access on undefined/null throws a raw "Runtime Error" string instead of a guest TypeError #676 — interpreter property access on undefined/null throws a raw "Runtime Error" string instead of a guest TypeError (broader, not generator-specific; surfaced while confirming instanceof TypeError is false for errors caught inside a compiled generator body #543).

Testing

• Full SharpTS.Tests suite green: 12714 passed, 0 failed, 0 skipped.
• New cross-mode regression tests: GeneratorTryFinallyTests (Compiled generator: a throw from inside a catch body is not caught by an enclosing flag-based try/catch (sync + async) #632 — rethrow, intervening finally, catch-less try/finally, throw-from-finally, two nested finallys, external throw() at a catch-body yield), AsyncGeneratorTryFinallyTests (Compiled async generator: throwing null/undefined into a flag-based try/catch skips the catch (async analog of #619) #628 + Compiled generator: a throw from inside a catch body is not caught by an enclosing flag-based try/catch (sync + async) #632, CompiledOnly per the Interpreted async generator: body side effects run out of order vs for-await-of consumer (eager drain) #564 eager-drain ordering), GeneratorErrorIdentityTests (instanceof TypeError is false for errors caught inside a compiled generator body #543), plus ILVerify (CompileAndVerifyOnly) guards for every new shape.
• Test262: unaffected — the committed subset includes no generator/async-generator folders, so these compiled-generator changes cannot shift the baseline.

Closes #628, closes #632, closes #617, closes #543.