bugfix: mono cursor misalignment at poly-free-fn Var with class-constrained Forall

When `synth` visits a `Term::Var v` where v is a polymorphic free fn
whose `Type::Forall` carries class constraints (e.g. `print : forall a.
Show a => ...`, `lt`/`le`/`gt`/`ge : forall a. Ord a => ...`), it
pushes BOTH a class `ResidualConstraint` for each constraint AND a
`FreeFnCall` observation at the same Var site. The mono walkers
(`interleave_slots` collection-side and `rewrite_mono_calls`
rewrite-side) consumed only ONE slot per such Var, leaving the
class-residual cursor misaligned for every subsequent class-method
call in the same body. The next `eq`/`compare` Var in the body then
consumed the leftover `Show T` / `Ord T` slot and was mis-rewritten —
codegen reported `call prelude.show__Bool arg type mismatch: expected
i1, got i64` (or the Int dual).

Fix: new `poly_free_fn_constraint_counts_for_module` registry in
mono.rs (sibling to `poly_free_fn_names_for_module`) maps each
synth-visible poly-free-fn name to its declared constraint count.
Threaded into `collect_residuals_ordered`, `interleave_slots`, and
`rewrite_mono_calls`. Both walkers now advance the cursor by 1 + N
(FreeFn slot + N class-residual fillers) at every poly-free-fn Var.

RED test `print_with_class_method_arg_does_not_misalign_mono_cursor`
(crates/ail/tests/show_print_e2e.rs) + fixture
examples/print_eq_arg_repro.ail pin the bug — body `(app print (app
eq 1 2))` previously crashed at codegen, now prints "false".

Bug surfaced 2026-05-14 during the rpe.1 BLOCKED orchestrator run;
existed in latent form since iter 24.3 (the poly-free-fn-with-class-
constraint synth shape was new there). No schema / codegen / DESIGN.md
changes. cargo test --workspace: 564 / 0 / 3.

crates/ail/tests/show_print_e2e.rs

@@ -72,3 +72,36 @@ fn print_user_adt_runs_end_to_end() {
     // IntBox that unwraps via match + int_to_str).
     assert_eq!(stdout, "7", "got: {stdout:?}");
 }
+
+/// RED pin (rpe-bug-1, 2026-05-14): `(app print <arg>)` where `<arg>`
+/// contains a class-method call (here `eq 1 2 : Bool`) must lower
+/// cleanly. The iter 24.3 rewire taught `synth` to push a `Show T`
+/// residual for `print`'s declared constraint at the same `Var` site
+/// where the poly-free-fn observation is pushed (see
+/// `crates/ailang-check/src/lib.rs` lines 2908-2960). But the
+/// mono-rewrite walker in `crates/ailang-check/src/mono.rs`
+/// (`interleave_slots` and `rewrite_mono_calls`) treats every
+/// poly-free-fn `Var` as consuming exactly one free-fn slot — it does
+/// not advance the class-residual cursor for the constraint that was
+/// pushed at the same site. The consequence is a one-position
+/// misalignment: the *next* class-method call in the body consumes
+/// the `Show T` slot, rewriting `eq` → `show__Bool`. Codegen then
+/// reports `call prelude.show__Bool arg type mismatch: expected i1,
+/// got i64`.
+///
+/// Property protected: a `print` call whose argument contains a
+/// class-method invocation lowers to a valid IR call sequence — the
+/// `eq` (or other class-method) call is rewritten to its correct
+/// mono symbol, not to a stale `Show T` residual symbol.
+///
+/// Fixture `examples/print_eq_arg_repro.ail` exercises the shape
+/// `(app print (app eq 1 2))`. Expected stdout: `"false"` (Show Bool
+/// of `eq 1 2` → false). This test is GREEN once the cursor
+/// alignment in `interleave_slots` / `rewrite_mono_calls` is fixed
+/// to advance the class cursor for constraints carried by a
+/// poly-free-fn Var.
+#[test]
+fn print_with_class_method_arg_does_not_misalign_mono_cursor() {
+    let stdout = build_and_run("print_eq_arg_repro.ail");
+    assert_eq!(stdout, "false", "got: {stdout:?}");
+}