Fix #668 #646 #640: optional/default parameter handling (type-checker + compiled)

[nickna]

Completes #668, #646, and #640 — all optional/default-parameter handling, fixed in dependency order.

#668 — type checker rejected explicit undefined for optional/default params

An optional (x?: T) or default-valued (x: T = ...) parameter now accepts an explicit undefined argument at the call site (its call-site type is T | undefined); passing undefined to a default-valued parameter triggers the default. tsc allows this; we emitted TS2345.

• New IsArgumentCompatible(paramType, argType, optional) helper in TypeChecker.Compatibility.cs — fast-path IsCompatible, else (when optional) retry against T | undefined.
• Applied at the regular-call (TypeChecker.Calls.cs), private-method (TypeChecker.Properties.cs), and constructor (TypeChecker.Properties.New.cs) argument-check sites. optional = position >= MinArity (both ? and = default reduce MinArity).
• Required params still reject undefined; rest-parameter elements are not widened (matching tsc).

#646 — compiled function expressions / arrow functions ignored defaults for omitted args

Two root causes:

1. A value-type default slot (y: number = 3) emitted invalid ldarg; brfalse IL (StackUnexpected) and the default never fired. Arrows/function-expressions get no OverloadGenerator lower-arity forwarding, so the runtime entry prologue is their only default mechanism — and it needs an object slot to detect a missing/undefined argument. ParameterTypeResolver.WidenDefaultedParamsToObject now widens every defaulted arrow/function-expression parameter to object (a typed reference slot like string coerces the sentinel to the literal "undefined" before the prologue, so widening value-types alone is insufficient).
2. AsyncArrowMoveNextEmitter never emitted the default prologue at all — it now does (placed after state dispatch so it runs only on initial entry), with arrow.Parameters threaded through its EmitMoveNext call sites.

#640 — compiled value-calls padded omitted optional args with CLR null

Calling a user function as a value (cross-module imports, callbacks, $TSFunction.Invoke) now pads omitted trailing optional arguments with the undefined sentinel instead of CLR null, so typeof / === undefined / === null answer correctly and object-slotted defaults fire.

• A $PadUndefined marker attribute (mirroring the existing $CapturesArguments) tags user functions.
• $TSFunction caches a _padUndefinedMask at construction: bit i set iff the wrapped method is marked and parameter i has an object slot. AdjustArgs pads the sentinel only at masked positions.
• Typed default slots (string/double) and runtime built-ins keep null padding — built-ins null-check optional-arg absence, and a typed slot can't hold the sentinel (it would coerce before the prologue). This object-slot mask is what makes sentinel-vs-null correct and perf-neutral.
• Marker applied to function declarations, sync arrows (static + display-class), inner functions, and async-arrow stubs.

Tests

New regression tests, both modes where applicable:

• TypeCheckerTests/OptionalParamUndefinedArgTests.cs
• CompilerTests/ArrowFunctionDefaultParameterTests.cs (incl. an IL-verification guard)
• CompilerTests/ValueCallUndefinedPaddingTests.cs (incl. a built-in null-padding guard)

Verification: full suite 12797 passed / 0 failed; TypeScript conformance 31 / 0; Test262 default subset showed no bucket regressions before hitting the pre-existing 0x80131506 host crash (a documented .NET host/JIT flake, unrelated to these changes).

Follow-ups filed (out-of-scope gaps found along the way)

• Parser: optional parameter (x?: T) in a private method (#name) fails to parse #696 — parser can't parse an optional param in a private method (#m(b?: T))
• Default parameter value cannot reference an earlier parameter ((a, b = a * 2)) — "Undefined variable" #698 — a default value can't reference an earlier parameter (both modes)
• Compiled: class methods invoked as values still pad omitted optional args with null (not the undefined sentinel) #703 — class methods invoked as values still null-pad (scattered method-define sites)
• Compiled: value-type default parameters cannot represent an explicit/padded undefined (yields NaN) #705 — value-type default + explicit/padded undefined → NaN in func-decl/method/ctor and the --ref-asm value-call (needs a broad value-type→object widening; deferred for perf/blast-radius)

Reviewer notes

• The --ref-asm (reference-assembly emit) path makes _types.Object != typeof(object); the widen helper takes the compilation's object type rather than hardcoding typeof(object).
• An earlier cut padded $Undefined for all slots and regressed 24 tests (typed string-defaults coerced the sentinel) — the object-slot mask is the fix.