Perf #861: de-virtualize annotated-param array HOF callbacks

[nickna]

Part of #856 (perf epic), closes #861. The last reflective-dispatch hotspot in the epic — the same class of cost #858 won ~40× on, now for array higher-order-function callbacks.

Problem

arr.map/filter/reduce/forEach/find/some/every already had a direct-delegate fast path (TryEmitDirectDelegateCall → Array*Direct(List<object>, Func<object,…>), "#96 Phase A"), but it bailed on annotated callback params (if (p.Type != null) return false). An annotated arrow (x: number): number => x*2 compiles to a typed static method double(double) that cannot bind to Func<object,object>, so idiomatic TypeScript (which annotates callback params — including the entire array-methods benchmark) fell back to the reflective ArrayMap + $TSFunction/MethodInvoker path: a MethodInvoker.Invoke + a 3-element object[] allocation + boxing per element.

Fix (4 layers)

L1 — boxed adapter (non-capturing). A new ArrowBoxedAdapterEmitter emits a per-arrow object(object[,object]) adapter that unboxes each boxed element into the arrow's typed slot, calls the typed arrow, and reboxes the result; it binds to the existing Func<object,…> and feeds the unchanged Array*Direct helpers. Marshalling reuses DelegateAdapterEmitter.EmitUnboxForReturn/EmitBoxForTS (now internal static), which matches the reflective MethodInvoker no-arg-conversion semantics exactly for concrete double/bool/string params (unions/nullable already widen to object in ParameterTypeResolver). The adapter is emitted onto the arrow's staticMethod.DeclaringType (not ctx.ProgramType, which is set only on the top-level context) so it fires inside function/method bodies too — the dominant benchmark case.

L2 — chained-stage round-trip elimination. a.map(f).filter(g).reduce(h) wrapped each intermediate result into a $Array only for the next stage to unwrap it. A recursive leaveResultAsBareList flag now lets the inner stage leave a bare List<object> and the outer skip the unwrap; the final stage still wraps when consumed as an array value (.length/assign/===). The intermediate is anonymous, so its $Array identity is unobservable. Disabled for returnsReceiver mutators (sort/reverse/fill/copyWithin) and the await-spill path.

L3 — capturing annotated arrows. A capturing arrow compiles to a typed instance Invoke on a display class. L3 emits the adapter as an instance method on that display class (callvirt this.Invoke) and binds (displayInstance, ldftn adapter), building the display instance fresh at the call site via the existing machinery (exposed through IEmitterContext.TryEmitCapturingArrowDisplayInstance). Per-iteration fresh-binding is preserved (a loop over arr.map(x => x + i)[0] yields 10,11,12, not a shared i).

L4 — bool-returning adapter for typed predicates. filter/find/findIndex/some/every with a typed bool predicate now bind Func<object,bool> + the existing *DirectBool helper, with the adapter returning the unboxed bool — dropping the per-element result box + IsTruthy.

Performance (warm, .NET 10 Release, controlled same-session A/B)

Workload	main	this PR
array-methods chain (non-capturing, n=10k)	~3.31 ms/call	~1.4 ms/call	~2.4×
chain with a capturing callback	~3.16 ms/call	~1.10 ms/call	~2.9×
pure filter (L4 delta vs L3)	~0.83 ms/call	~0.79 ms/call	~5%

L2 is allocation/GC + cold-start (warm-flat on large-n, where per-element work dominates) — the chained map().filter().reduce() emits zero newobj $Array/get_Elements between stages (IL-verified). All outputs identical to main.

Correctness / scope

Conservative and additive: anything outside the fast path (capturing/marshallable gates, multi-arg callbacks, rest/optional/default params, non-array receivers) falls back to the unchanged reflective path. The standalone-DLL constraint is preserved (adapters are emitted methods, no SharpTS.dll reference). arr.map((x:number)...) etc. — capturing or not — now emit a direct delegate call with no $TSFunction/GetMethodFromHandle/object[] per element.

Tests

• 42 new dual-mode tests (ArrayHofAnnotatedCallbackTests): annotated map/filter/reduce/forEach/find/some/every, string-param + NaN coercion parity, chained stages (final-wrap-preserved, map→slice boundary, mixed typed/untyped), capturing (map/reduce/chained + the per-iteration fresh-capture guard), bool predicates, and fallback cases (any[], multi-arg, untyped).
• --verify clean on all shapes.
• Full dotnet test green except the two known pre-existing stale/flaky Test262 baselines: their only "regressions" are Array/isArray TypeCheckError/Proxy drift that also appears in interpreter mode (a compiled-only change cannot cause those), and the non-Test262 flaky failures pass in isolation with disjoint sets across runs. No HOF/callback/closure/predicate test changed status.