Iter 16e: == polymorphic over Int / Bool / Str / Unit

Lifts the Int-only restriction on `==`. Declared type becomes
forall a. Fn(a, a) -> Bool; codegen monomorphises and dispatches:

  Int  → icmp eq i64
  Bool → icmp eq i1
  Str  → call @strcmp + icmp eq i32 0
  Unit → constant true (operands still emitted for side effects)
  ADT / Fn / other → CodegenError::Internal

This unblocks 16c's build_eq for non-Int lit patterns. == joins
__unreachable__ as the second polymorphic builtin (same Forall
machinery).

- check/builtins.rs: == registered as Forall(a, Fn(a, a) -> Bool).
- codegen: lower_eq dispatch table; @strcmp declared in IR header
  alongside @printf/@GC_malloc/@puts.
- examples/eq_demo.{ailx,ail.json}: covers all four supported
  scalars including a Str-lit-pattern match.
- IR snapshots refreshed: only +declare i32 @strcmp(ptr, ptr) in
  the header; every define body bit-identical.
- e2e + check + codegen tests: 124 → 133 (+9, of which +1 is the
  e2e fixture and the rest exercise the new dispatch / typecheck
  surface).

Other comparison ops (<, <=, >, >=, !=) remain Int-only — out of
scope for this iter.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

examples/eq_demo.ail.json

@@ -0,0 +1 @@
+{"defs":[{"body":{"arms":[{"body":{"lit":{"kind":"int","value":1},"t":"lit"},"pat":{"lit":{"kind":"str","value":"hi"},"p":"lit"}},{"body":{"lit":{"kind":"int","value":2},"t":"lit"},"pat":{"lit":{"kind":"str","value":"ho"},"p":"lit"}},{"body":{"lit":{"kind":"int","value":0},"t":"lit"},"pat":{"p":"wild"}}],"scrutinee":{"name":"s","t":"var"},"t":"match"},"doc":"Lit-pattern over Str; exercises 16c's build_eq for non-Int.","kind":"fn","name":"classify_str","params":["s"],"type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Str"}],"ret":{"k":"con","name":"Int"}}},{"body":{"lhs":{"args":[{"args":[{"lit":{"kind":"int","value":5},"t":"lit"},{"lit":{"kind":"int","value":5},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"int","value":5},"t":"lit"},{"lit":{"kind":"int","value":6},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"bool","value":true},"t":"lit"},{"lit":{"kind":"bool","value":false},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"bool","value":true},"t":"lit"},{"lit":{"kind":"bool","value":true},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"str","value":"hi"},"t":"lit"},{"lit":{"kind":"str","value":"hi"},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"str","value":"hi"},"t":"lit"},{"lit":{"kind":"str","value":"ho"},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"unit"},"t":"lit"},{"lit":{"kind":"unit"},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"}],"op":"io/print_bool","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"str","value":"hi"},"t":"lit"}],"fn":{"name":"classify_str","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"str","value":"ho"},"t":"lit"}],"fn":{"name":"classify_str","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"rhs":{"args":[{"args":[{"lit":{"kind":"str","value":"??"},"t":"lit"}],"fn":{"name":"classify_str","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"t":"seq"},"t":"seq"},"t":"seq"},"t":"seq"},"t":"seq"},"t":"seq"},"t":"seq"},"t":"seq"},"t":"seq"},"doc":"Drive == at Int/Bool/Str/Unit; then drive classify_str.","kind":"fn","name":"main","params":[],"type":{"effects":["IO"],"k":"fn","params":[],"ret":{"k":"con","name":"Unit"}}}],"imports":[],"name":"eq_demo","schema":"ailang/v0"}

examples/eq_demo.ailx

@@ -0,0 +1,56 @@
+; Iter 16e — `==` extends from Int-only to Int/Bool/Str/Unit (polymorphic
+; dispatch). The builtin's declared type became
+;   forall a. (a, a) -> Bool
+; and codegen monomorphises on the resolved arg type:
+;   Int  → icmp eq i64
+;   Bool → icmp eq i1
+;   Str  → @strcmp + icmp eq i32 0
+;   Unit → constant i1 true (single-inhabitant type)
+;   ADT/Fn → rejected at codegen with a clear error.
+;
+; This fixture exercises all four supported types, both directly via
+; `(app == ...)` and indirectly via 16c's lit-pattern desugar (which
+; rewrites `(pat-lit "hi")` → `(if (== sv "hi") body fall_k)` and
+; therefore inherits 16e's polymorphic `==`).
+;
+; Expected stdout (one per line):
+;   true   ; (== 5 5)
+;   false  ; (== 5 6)
+;   false  ; (== true false)
+;   true   ; (== true true)
+;   true   ; (== "hi" "hi")
+;   false  ; (== "hi" "ho")
+;   true   ; (== () ())
+;   1      ; classify_str "hi"   (lit-pattern hits 1 arm)
+;   2      ; classify_str "ho"   (lit-pattern hits 2 arm)
+;   0      ; classify_str "??"   (default arm)
+;
+; Driver lowers via io/print_bool / io/print_int.
+
+(module eq_demo
+
+  (fn classify_str
+    (doc "Lit-pattern over Str; exercises 16c's build_eq for non-Int.")
+    (type (fn-type (params (con Str)) (ret (con Int))))
+    (params s)
+    (body
+      (match s
+        (case (pat-lit "hi") 1)
+        (case (pat-lit "ho") 2)
+        (case _ 0))))
+
+  (fn main
+    (doc "Drive == at Int/Bool/Str/Unit; then drive classify_str.")
+    (type (fn-type (params) (ret (con Unit)) (effects IO)))
+    (params)
+    (body
+      (seq (do io/print_bool (app == 5 5))
+      (seq (do io/print_bool (app == 5 6))
+      (seq (do io/print_bool (app == true false))
+      (seq (do io/print_bool (app == true true))
+      (seq (do io/print_bool (app == "hi" "hi"))
+      (seq (do io/print_bool (app == "hi" "ho"))
+      (seq (do io/print_bool (app == (lit-unit) (lit-unit)))
+      (seq (do io/print_int (app classify_str "hi"))
+      (seq (do io/print_int (app classify_str "ho"))
+           (do io/print_int (app classify_str "??"))))))))))))))