Close 33.5% of the interp↔compiled Test262 divergence (#1279)

[nickna]

Progress on the standing task in #1279. Divergence between the two execution
modes drops 2236 → 1486 (−33.5%).

	before	after	Δ
Divergence	2236	1486	−750
Interpreted Pass	6929	7642	+713
Compiled Pass	8003	8089	+86
Interpreted Timeout	1	0	−1

Divergence histogram

count	interp → compiled	before
654	Fail → Pass	984
270	Pass → Fail (compiled bug)	263
155	RuntimeError → Pass	475
148	RuntimeError → Fail	227
146	Fail → RuntimeError	145
92	Pass → RuntimeError (compiled bug)	121
18	Fail → HarnessError	18
1	Pass → Timeout	1
1	Fail → Timeout	1

Track A (interpreter deficits) went 1459 → 809. Track B (compiled deficits)
went 384 → 363 — it dipped to 346 after the compiled batch, then rose slightly
as the interpreter became correct in places the compiler still isn't
(Object.getPrototypeOf(RangeError), non-configurable instance properties).
Those are genuine compiler bugs the interpreter now exposes.

---

Commits

Each is one coherent root-cause group, with before/after numbers in its message.

1. cfea32b5 — built-in property & coercion gaps (interpreter, 476 tests)

Seven root causes. Unbound prototype methods lost their receiver on a member
call, so arr.getClass = Object.prototype.toString; arr.getClass() threw.
Built-in prototypes and constructors didn't inherit Object.prototype.
name/length on built-in functions weren't deletable and read back as "".
Numeric built-in arguments were read with RuntimeValue.AsNumber(), a kind
assertion — Math.abs("-5") crashed with a host message that reached guest
catch as a bare string; all 106 argument reads now run ToNumber, and
ToNumber(Symbol) raises a guest TypeError. 13 Math functions and the Annex B
accessors were missing entirely. The primitive prototypes didn't carry their own
primitive value. JSON.parse threw a host Exception.

2. 1b2ba989 — prototype identity, Promise.prototype, iterable combinators (interpreter, 170 tests)

X.prototype minted a fresh wrapper per read, so TypeError.prototype !== TypeError.prototype. Object.getPrototypeOf reported null for plain object
literals. Promise.prototype read as undefined. The Promise combinators
demanded a literal array rather than any iterable.

3. d16da1db — Date.prototype, descriptor-bag getters, array-index accessors (compiler, 85 tests)

Date.prototype read as undefined — Date instance calls compile inline, so
the prototype object was never materialized and every reflective use of it died
on a null receiver. The compiled Object.create walked the descriptor bag's
backing dictionary directly and dropped accessor entries. Array indices couldn't
carry accessor descriptors.

4. a23c90f3 — built-in prototypes as ordinary objects (interpreter, 61 tests)

Object.prototype was backed by a value-only Dictionary and supported
none of defineProperty / index assignment / delete / for...in. Also:
obj[k] and obj.k disagreed — indexed reads skipped getters, the __proto__
walk and the Object.prototype fallback.

5. 8b66c01f — per-realm constructor objects (interpreter, 6 tests)

Small delta, but closes a real gap (Number.foo = 1 threw) and a
baseline-stability bug: the Object.prototype methods were handed to guest
code as process-wide statics carrying mutable §17 metadata, so one program's
delete fn.length was visible to every later program in the same process.
Results were order-dependent — Object/prototype/toString/length.js passed
alone and failed in a full run.

---

A note on method

Several of these bugs were duplication bugs, and the fixes remove the
duplication rather than patching the copy:

• Compiled ObjectCreate kept a thinner copy of ObjectDefineProperties'
  props loop; it now delegates.
• Object.hasOwn was a thinner reimplementation of HasOwnProperty; they now
  share one implementation.
• Indexed and dotted property reads had separate paths; indexed now routes
  through the dotted one.
• Six near-identical switch arms named each prototype singleton individually —
  which is how Object.prototype came to be missing from one and
  Number.prototype from another. Introduced ISharpTSMutableBuiltIn and
  collapsed them.

Verification

• dotnet test green: 16,279 / 16,279.
• 339 Test262 parity tests in Issue1279ParityTests (33 new), all green.
• SharpTS.TypeScriptConformance baseline unchanged.
• Both Test262 baselines regenerated together against this commit.
• Zero regressions, verified test-by-test rather than in aggregate: every
  one of the 7,636 previously-passing interpreted tests and all 8,003
  previously-passing compiled tests re-run individually after each batch.

Known gaps, deliberately left

• Promise combinators are eager. They materialize the iterable up front
  instead of interleaving with C.resolve, so 13 Test262 cases with infinite
  iterators still fail. A documented cap (MaxCombinatorElements) turns what
  was a hang into a prompt rejection — they fail fast rather than burning the
  per-test timeout. Making the combinators lazy would fix them properly.
• Three Array/prototype/lastIndexOf tests build 2^32-element sparse arrays
  and take ~4.5s each. One regen flaked them to Timeout; timed with and
  without these changes and they're unaffected, but they sit close enough to the
  per-test budget to destabilize the committed baseline.
• DnsRecordTypeTests.LiveSmoke_ResolveNs_Promise hits real DNS and flaked
  once mid-session. Pre-existing and unrelated, but it will flake in CI.
• Array/from/iter-map-fn-err.js trips a 2.5 GB memory watchdog in compiled
  mode on an error path. Pre-existing.

What's next

Per-batch yield fell 646 → 170 → 85 → 61 → 6 as the fat clusters cleared.
Track A's largest remaining group is 57 Expected SameValue spread across a
dozen folders; nothing left resembles the single-root-cause wins above.
Track B's 363 is now the better seam — Expected a $TypeError (16),
array-index descriptor value drift (11), and a host Parse leaking through
length coercion (7).

Refs #1279.