Fix async/generator IL & interpreter bugs (#727 #728 #721 #720)

[nickna]

Fixes four compiled/interpreter async & generator bugs. Each fix ships with cross-mode (interpreter + compiled) parity tests and, where the bug was invalid IL, an IL-verification test.

#727 — Compiled async function: break/continue out of a try emits invalid IL

AsyncMoveNextEmitter lacked the protected-region-aware branching the generator emitters have, so a break/continue leaving a try inside an async body emitted a Br out of the real IL exception region (BranchOutOfTry → InvalidProgramException at AsyncMethodBuilderCore.Start).

• Override EmitBranchToLabel to emit Leave when inside a real IL exception block (ExceptionBlockDepth, incremented in EmitSimpleTryCatch).
• Treat an escaping break/continue/return as a segment-breaker in EmitTryBodyWithAwaits so its jump lands at the top level (outside the mini IL try), mirroring the generator's IsSegmentBreaker design.
• De-dup: hoist the verbatim-duplicated ContainsEscapingExit/ContainsEscapingExit2 analysis (it lived in both the generator and async-generator emitters) into the shared StatementEmitterBase.

#728 — Labeled for await...of iterated synchronously (interpreter + compiled)

outer: for await (...) ignored Stmt.ForOf.IsAsync on the labeled path, throwing "requires an iterable" (interpreter) or failing to compile ("Label N has not been marked") while the unlabeled form worked.

• Interpreter: register an async LabeledStatement handler so a labeled loop runs through the async path (where for-await routes to the async iterator), and have the async loops drain TakePendingLoopLabels() so break/continue <label> match. (This also fully resolves the async-function case of Interpreter: labeled loop containing await/yield fails in async functions and async generators #770 and a labeled-break-out-of-async-try interpreter bug.)
• Compiled: AsyncMoveNextEmitter.EmitLabeledForOf delegates to EmitForAwaitOf when IsAsync, threading the chain's labels into the loop scope.

#721 — Redundant dead async state machine for method-nested async arrows

An async arrow nested in an async class method got two async state machines: the live nested one and a dead standalone duplicate (DefineTopLevelAsyncArrows ran before class-method state machines registered their arrows). Skip an arrow that an enclosing async function/method's state machine will claim, detected by walking the enclosing-callable chain (all-async up to an async Stmt.Function). Removes the dead duplicate (2→1 type for the direct case, 4→2 for nested async arrows) with no effect on any working case (arrows behind a sync arrow/method, or genuinely top-level, still get their needed standalone builder).

#720 — Compiled async/generator private methods (async #m, *#m, async *#m) emit invalid IL

Private methods were emitted linearly into __private_<name> regardless of kind — bare object on the stack for an async method declared Task<object> (StackUnexpected), and yield rejected. EmitPrivateMethodBody now routes by kind through the same state-machine path as public methods:

• EmitAsyncMethodBody generalized with isInstanceMethod + nullable fieldsField + qualified currentClassName → serves instance and static private async.
• Instance async/generator/async-generator and static async + static generator (the latter enabled by integrating Compiled mode: static generator method (static *m()) fails with "Yield not supported in this context" #692) all route through their state machines. Return types fixed via ResolvePrivateMethodReturnType; generator/async-generator stubs box from the method's actual IL signature (private params are all object slots).
• Static async generators stay on the linear path (clean "Yield not supported", the public static async-generator gap Compiled mode: static async generator method (static async *m()) fails with "Yield not supported in this context" #761), not invalid IL.

Merge integration

Branch based on 909ff2f2; merged current origin/main (15 commits) and reconciled with concurrent work touching the same subsystems — #692 (static generators), #704 (async chained labels → plural labelNames threaded through the for-await fix), #675/#691/#559 (generator/async-generator try-flow machinery, which now consumes the shared ContainsEscapingExit). Because #692 landed static generator support, #720 also fixes static private generators.

Follow-ups

• Filed Compiled async function: break/continue out of a try-with-awaits does not run the try's finally #774 — compiled async function break/continue out of a try-with-awaits doesn't run the finally (the semantics half of Compiled (async function): break/continue out of a try emits invalid IL #727; the invalid-IL half is fixed here).
• Pre-existing gaps confirmed out of scope and already tracked: Compiled: value-type default parameters on (virtual) instance & static methods are not applied #737 (value-type default params on compiled class methods), Compiled mode: static async generator method (static async *m()) fails with "Yield not supported in this context" #761 (static async generators), Interpreted async generator: body side effects run out of order vs for-await-of consumer (eager drain) #564/Interpreter: async generator leaks its closure when an await is nested inside a delegated expression (yield f(await x)) #752 (interpreter async-generator for-await eager drain).

Testing

• New: AsyncTryControlFlowTests, LabeledForAwaitTests, AsyncArrowNoDeadDuplicateTests (asserts the emitted state-machine count via reflection), PrivateAsyncGeneratorMethodTests.
• Full suite green: 13257 passed, 0 failed.
• Conformance suites (Test262 / TypeScriptConformance) not run — they are not in CI and their baselines are managed separately; the changes are covered by the main suite + targeted parity/IL-verification tests.