iter 24.3: fn print + E2E + 3 compiler-path repairs; milestone 24 close

Ships fn print : forall a. Show a => (a borrow) -> () !IO in the
prelude with explicit-let body \\x -> let s = show x in do
io/print_str s. Three new E2E fixtures + tests verify the full
path:

- show_print_smoke: 4 primitives smoke (print 42 / true / 'hello' /
  3.14) — compile, run, expected stdout
- show_user_adt: data IntBox + instance prelude.Show IntBox +
  print (MkIntBox 7) — stdout '7'
- show_no_instance: let f : Int -> Int = \\x -> x in do print f —
  fires Show-aware NoInstance with DESIGN.md §Prelude(built-in)
  classes cross-reference

IR-shape pin in print_mono_body_shape.rs asserts post-mono
print__Int.body is structurally Term::Let → App(show__Int) →
Do(io/print_str). Protects the explicit let-binder for the heap-Str
RC discipline per eob.1 Str carve-out.

Three plan-defects-fixed-inline surfaced during user-ADT E2E,
necessary repairs to make the spec's stated user-ADT trajectory
work end-to-end:

(a) mono.rs (2 sites): MonoTarget::FreeFn::type_args were carrying
    bare type-cons references; normalised to canonical
    <owner>.<bare> form via workspace_registry.normalize_type_for_lookup
    so synthesised cross-module bodies' post-mono walks reach the
    registry-keyed instance entries. Symmetric to the existing
    class-method-arm normalisation.

(b) codegen/lib.rs (3 sites: resolve_top_level_fn, lower_app
    cross-module arm, synth_with_extras Var arm): post-mono
    synthesised bodies may carry cross-module references to modules
    their source template didn't import (prelude.print__<UserType>
    references show_user_adt.show__<UserType> even though prelude
    does not import user modules). Fall back to direct
    module_user_fns lookup when prefix not in import_map. Both
    ends were independently typechecked before mono ran; the
    cross-module ref is created by mono not by source.

(c) lib.rs synth FreeFnCall arm: walked Type::Forall.constraints,
    substituted rigid vars with fresh metavars, pushed one
    ResidualConstraint per declared constraint. Without this,
    print f at Int -> Int would silently typecheck and fail with
    a confusing 'unknown variable: show' at codegen rather than
    fire the right typecheck-time NoInstance diagnostic.

NoInstance Float-aware arm in check/lib.rs:770-779 extended with
a parallel class == 'prelude.Show' branch that cross-references
DESIGN.md §Prelude(built-in) classes verbatim. Negative-fixture
test asserts code 'no-instance' + Show substring + Prelude-(built-in)-
classes substring.

DESIGN.md §Prelude(built-in) classes milestone-24 paragraph flips
fn print from 'ships in 24.3' to 'shipped in iter 24.3' with body
shape + pin file reference. §Float semantics gains a Show-Float
NaN-spelling cross-reference paragraph linking show 1.5 / show nan /
show inf to instance Show Float via float_to_str.

Roadmap P1 'Post-22 Prelude — Show + print rewire' flipped to [x]
with closing summary naming all three shipped iters (24.1 / 24.2 /
24.3). New P2 entry 'Retire io/print_int|bool|float effect-ops +
migrate example corpus to print' inserted at top of P2.

Tests: 556 passed (was 552 + 4 new). bench/cross_lang exit 0;
bench/compile_check + bench/check exit 1 on documented noise-class
metrics per the audit-cma lineage envelope (8th consecutive
audit-grade observation, baseline pristine per conservative-call).

Milestone 24 closes structurally with this iter. Standard audit
pipeline next.

docs/DESIGN.md

@@ -1898,16 +1898,21 @@ diagnostic cross-referencing this section.
 
 Milestone 24 amends the above further: the prelude ships `class Show
 a where show : (a borrow) -> Str` and primitive `Show Int`,
-`Show Bool`, `Show Str`, `Show Float` instances. Float **is** included
-in Show (unlike Eq/Ord) — IEEE-754 makes structural equality and total
-ordering semantically dubious, but textual representation of a Float
-is well-defined modulo the NaN-spelling caveat in §"Float semantics".
-Each `Show <T>` instance body is a single-application lambda invoking
-the corresponding runtime primitive (`int_to_str`, `bool_to_str`,
-`str_clone`, `float_to_str`); no codegen intercept is required. The
-polymorphic helper `print : forall a. Show a => a -> () !IO` ships in
-the same milestone as the second iteration (24.3) and routes through
-`show` and `io/print_str`.
+`Show Bool`, `Show Str`, `Show Float` instances (iter 24.2). Float
+**is** included in Show (unlike Eq/Ord) — IEEE-754 makes structural
+equality and total ordering semantically dubious, but textual
+representation of a Float is well-defined modulo the NaN-spelling
+caveat in §"Float semantics". Each `Show <T>` instance body is a
+single-application lambda invoking the corresponding runtime primitive
+(`int_to_str`, `bool_to_str`, `str_clone`, `float_to_str`); no codegen
+intercept is required. The polymorphic helper `print : forall a. Show
+a => a -> () !IO` shipped in iter 24.3 with body
+`\x -> let s = show x in do io/print_str s` (explicit let-binder for
+heap-Str RC discipline per eob.1 Str carve-out). The let-binder is
+structurally pinned by `crates/ail/tests/print_mono_body_shape.rs`.
+Routing through `print` replaces the ad-hoc `io/print_int|bool|float`
+idiom for new code; retiring the per-type effect-ops is queued as a
+P2 follow-up.
 
 Primitive output goes through `io/print_int` / `io/print_bool` /
 `io/print_str` directly.
@@ -2446,6 +2451,16 @@ no `f32` variant. The runtime / codegen contract:
   spelling and `io/print_float` is for human-readable output, not
   round-trip.
 
+The same libc-`%g` rendering applies to `show 1.5` / `show nan` /
+`show inf` via `instance Show Float` (which calls `float_to_str`
+internally — see §"Prelude (built-in) classes" for the Show ship).
+The NaN-spelling caveat above is observable via both
+`do io/print_float x` and `do print x` at the same `x`; the rendering
+is libc-version-dependent and target-libc-specific. AILang does NOT
+canonicalise Float textual representation; the LLM-author who needs
+deterministic Float rendering for cross-platform test fixtures should
+bypass `show` / `print` and emit a custom formatter.
+
 These are the Rust / Swift / standard-LLVM defaults — not
 research-grade reproducibility guarantees. The stronger guarantee
 (e.g. Pythonic `float.fromhex`-level bit reproducibility across