fix(monomorphize): ground enclosing-param method-generic turbofish per specialization

[math3usmartins]

A turbofish whose type argument comes from an enclosing generic scope was
rejected with xphp.unspecialized_generic_leak, so a generic class could not
delegate to a shared static generic helper (Maker::wrap::<T> inside Box<T>)
and had to inline the helper body at every call site. Reported by a
downstream consumer.

These shapes now ground per specialization and run:

• named free-function forwards: identity::<T>($v) inside wrap
• static calls: self::gen::<T>() and Maker::wrap::<T>() inside Box,
  including targets declared on a generic base class
• instance calls: $this->dup::<T>() and $m->dup::<T>() on a non-generic
  receiver typed parameter

Freshly specialized bodies are re-grounded transitively: multi-hop chains
and mutual recursion converge, while a strictly growing chain fails loudly
with the new xphp.unconverged_method_specialization. Grounded members are
deduplicated per unique argument tuple, and bounds that only become
provable after specialization are checked per instantiation. xphp check
now collects the same diagnostics compile raises, closing the gap where
check reported green on code compile rejected.

Still rejected loudly, by design: closure turbofish inside generic function
bodies, targets on a different generic template, the static::/parent::
spellings, and method-level parameter forwards to non-erasable targets.

See docs/caveats.md for the updated support matrix.

[greptile-apps]

Greptile Summary

This PR fixes a long-standing limitation: a turbofish whose type argument is an enclosing generic class parameter (e.g. self::gen::<T>() inside Box<T>) was previously rejected with xphp.unspecialized_generic_leak. The fix introduces a second grounding phase — groundSpecializedClass — that runs inside the fixed-point specialization loop, after class substitution has made those abstract type arguments concrete.

• A new GroundingContext value object threads the spec's identity, template FQN, and concrete type args into the existing rewrite machinery, which is re-invoked in markers-only mode per fresh specialization. Static calls, instance calls, and named free-function forwards are all handled; static::/parent:: spellings, cross-template targets, and closure turbofish deliberately keep their markers and fall to the existing assertNoLeak backstop.
• Freshly specialized bodies are drained transitively via a worklist: multi-hop chains and mutual recursion terminate through the shared alreadyGenerated dedup; strictly-growing chains halt at MAX_METHOD_SPECIALIZATION_HOPS = 16 with the new xphp.unconverged_method_specialization error code.
• xphp check is brought into full parity: groundSpecializedClass runs with emit: false inside the resilient fixed-point loop, collecting bound violations and surviving markers that were previously only reported by compile.

Confidence Score: 5/5

Safe to merge. The two-phase grounding and drain worklist are correctly implemented, convergence is capped, and check/compile parity is maintained.

The new grounding pass correctly defers to the retained Phase-1a template index, deduplicates appends via the shared alreadyGenerated map, threads concrete class args through the inheritance chain for both static and instance call shapes, and terminates growing chains at the same depth cap as the class-level loop. The check path runs the same machinery with emit: false, collects the same diagnostics, and feeds external appends into the resilient fixed-point loop so nested instantiation needs discovered by grounding converge correctly. No bugs were found in the changed paths.

Files Needing Attention: No files require special attention.

Important Files Changed

Filename	Overview
src/Transpiler/Monomorphize/GenericMethodCompiler.php	Core of the PR: adds groundSpecializedClass, drainSpecializedAppends, and a markersOnly/grounding mode to the rewrite visitor. The two-phase grounding, convergence cap, and dedup via alreadyGenerated are all sound.
src/Transpiler/Monomorphize/Compiler.php	Wires GenericMethodCompiler into specializeToFixedPoint for both compile and check paths; external appends from grounding are collected into the fixed-point loop. Logic is correct.
src/Transpiler/Monomorphize/GroundingContext.php	New lightweight value object threading spec identity, template FQN, concrete type args, and external-append accumulation into the grounding pass. Minimal surface, no issues.
src/Transpiler/Monomorphize/GenericMarkerLeakGuard.php	Adds skipUnspecializedTemplates and includeVariableTurbofish parameters to findLeak, correctly preventing false positives in check-mode spec backstop.
src/Transpiler/Monomorphize/Specializer.php	Extends the substituting visitor to ground ATTR_METHOD_GENERIC_ARGS on all four call-node types during class specialization, so enclosing type-param leaves become concrete before the grounding pass reads them.

Sequence Diagram

sequenceDiagram
    participant C as Compiler
    participant S as Specializer
    participant GMC as GenericMethodCompiler
    participant RC as RegistryCollector

    Note over C: Phase 1a - raw user ASTs
    C->>GMC: process(astPerFile, emit true)
    GMC-->>C: markers deferred (T still abstract)

    Note over C: Phase 2 - fixed-point loop
    loop per instantiation e.g. Box_int
        C->>S: specialize(Box_T, T to int)
        S-->>C: Box_int spec with self::gen::int marker
        C->>GMC: "groundSpecializedClass(spec, Box_int, classArgs=[int], emit true)"
        Note over GMC: markers-only walk on spec
        Note over GMC: self::gen::int appended onto spec
        Note over GMC: Maker::wrap::int goes to externalAppends
        Note over GMC: drain loop re-walks appended bodies
        GMC-->>C: externalAppends list
        C->>RC: collect(externalAppends)
        C->>RC: collect([spec])
    end

    Note over C: Phase 3+ emit and leak-guard

Loading

_{Reviews (3): Last reviewed commit: "docs: clarify that forwarding a method-l..." | Re-trigger Greptile}