fix: standalone async-generator test262 parity (57.7% → 93.0%)

[proggeramlug]

Drives standalone async function* (declarations + expressions) test262 parity from 57.7% → 93.0% across language/expressions/async-generator + language/statements/async-generator (pass 512 → 826 / 888, runtime-fail 181 → 21, compile-fail 0). Four root causes, each spec-justified, gated to stay inert outside the affected shapes.

Root causes & fixes

1. Destructuring param + default dropped the binding; destructuring defaults skipped NamedEvaluation (fix(hir))

• async function*([x,y,z]=[1,2,3]){} (expression form) lowered only the default guard, not the destructuring binding — x/y/z resolved to js_throw_reference_error_unresolved_get. lower_arrow / lower_fn_expr / nested_fn_decl now unwrap Pat::Assign to the inner pattern before is_destructuring_pattern, mirroring the already-correct lower_fn_decl.
• [fn = function(){}] left fn.name empty instead of "fn". destructuring/pattern_binding now threads the single-name binding into ctx.assignment_inferred_name for anonymous fn/arrow/class defaults at all three default sites.

2. Generator param binding ran on first .next() instead of at call time (fix(transform))

• Per spec, generator/async-generator parameter binding (FunctionDeclarationInstantiation) runs synchronously when the function is called, before the generator object is created — so an iterator / RequireObjectCoercible / TDZ error during destructuring or default evaluation throws at call time. Perry linearized the param prologue into state 0 of .next(), so a test that only calls f(badIterable) (expecting a synchronous throw) never ran it.
• Lowering records the prologue length per generator func_id (Module.gen_param_prologue_len); the transform lifts those leading statements into the outer wrapper, boxing their bound locals so the state machine still reads the destructured values. Gated on is_generator (plain async functions keep reject-not-throw semantics) and inert when prologue_len == 0. This fix alone collapsed runtime-fail 181 → 21.

3. yield E didn't Await its operand (fix(transform))

• Per spec, yield E in an async generator is AsyncGeneratorYield(? Await(E)) — yield Promise.reject(x) throws x into the generator and yield Promise.resolve(v) yields v. A pre-pass (after hoist_yields) rewrites each statement-level non-delegate yield E into let __ayield = await E; yield __ayield, reusing the existing suspension machinery. yield* delegation untouched.

Verification & zero-regression check

• All four fixes verified byte-identical to node --experimental-strip-types.
• Targeted sweep over language/{expressions,statements}/{generators,async-function} (shared state machine): 90.4%, no new crashes — the param-prologue lift is spec-correct for sync generators too.
• Broad shard 0/12 over built-ins language vs an origin/main baseline (same shard/harness): +33 pass, −10 runtime-fail, compile-fail unchanged (18). The one apparent "regression" (TypedArray/prototype/forEach/returns-undefined.js) is a pre-existing non-deterministic GC/layout-sensitive segfault (passed run 3/3 on a commit-1-only build) surfaced by layout shift, not introduced logic.

Remaining (62, mostly out of scope)

~50 are precise yield* async-delegation tests (exact getter ordering, async-from-sync ticks, return/throw forwarding, abrupt-completion propagation) — a separate AsyncGeneratorYield* reimplementation. ~12 are prototype-chain edge cases.