Chez Phase 1 (increment 3c): multi-arity + variadic fn emission

emit-fn lowered multi-arity fns to a Scheme case-lambda and variadic fns to
a rest-arg lambda; the Scheme rest list is coerced to a jolt seq (nil when
empty, via list->cseq), and the named-let wrapper runs that coercion only on
first entry so recur carries the seq directly. Single fixed arity keeps the
plain-lambda fast path (fib untouched).

Also fixes a latent leak in the module-global known-procs: a throw mid-emit
(uncompilable body) left the fn's name registered, so a later corpus case
binding the same name to a keyword emitted a direct call to a non-procedure.
The cleanup now runs on the error path too. Only surfaced once the new arity
support let +24 cases compile further before hitting an uncompilable fn.

Gate: emit-test 81/81, subset probe 619/619 compiled (was 595), 0 divergences,
2036/2655 out of subset; full run-tests green (125 files).

test/chez/README.md

@@ -48,13 +48,19 @@ compile-time signal) and are counted "out of subset", not as divergences.
 
     JOLT_CHEZ_CORPUS=1 janet test/chez/run-corpus-chez.janet
 
-Baseline after inc 3b (seq tier + dynamic IFn, jolt-5pso): **595/595 compiled
-cases pass**, 0 divergences; 2060/2655 out of subset (await clojure.core on Chez).
-The seq tier brought up a list/lazy-seq type with first/rest/next/seq/cons/list,
-map/filter/reduce/into/remove, range/take/drop/concat/apply, keys/vals, and
-nth/peek/pop over seqs; dynamic IFn dispatch (a keyword/vector/coll held in a
-local and called as a fn) now routes through the `jolt-invoke` fallback, closing
-the 3 ex-known divergences. The probe exits non-zero on any NEW divergence.
+Baseline after inc 3c (multi-arity + variadic fns, jolt-gret): **619/619 compiled
+cases pass**, 0 divergences; 2036/2655 out of subset (await clojure.core on Chez).
+`emit-fn` now lowers multi-arity fns to a Scheme `case-lambda` and variadic fns to
+a rest-arg lambda (the Scheme rest list is coerced to a jolt seq, nil when empty),
+which is the gating lift for emitting the clojure.core tiers as a prelude.
+
+Prior, inc 3b (seq tier + dynamic IFn, jolt-5pso): 595/595 compiled, 0 divergences,
+2060/2655 out of subset. The seq tier brought up a list/lazy-seq type with
+first/rest/next/seq/cons/list, map/filter/reduce/into/remove,
+range/take/drop/concat/apply, keys/vals, and nth/peek/pop over seqs; dynamic IFn
+dispatch (a keyword/vector/coll held in a local and called as a fn) routes through
+the `jolt-invoke` fallback, closing the 3 ex-known divergences. The probe exits
+non-zero on any NEW divergence.
 
 (Prior, inc 3a: 433/436 compiled, 3 known IFn divergences, 2219 out of subset.
 Inc 2: 182/182 compiled, 0 divergences, 2473 out of subset.)

test/chez/emit-test.janet

@@ -185,6 +185,28 @@
     (ok (string "seq=: " src) (and (= code 0) (= out "true"))
         (string "chez=" out " | " err))))
 
+# 3g) multi-arity + variadic fns (inc 3c): case-lambda dispatch, a Scheme rest
+#   arg collected into a jolt seq (nil when empty), recur within an arity and a
+#   self-call across arities. Value parity vs the CLI oracle.
+(each src ["((fn ([x] (* x 2)) ([x y] (+ x y))) 5)"
+           "((fn ([x] (* x 2)) ([x y] (+ x y))) 3 4)"
+           "(defn g ([x] x) ([x y] (+ x y))) (g 10)"
+           "(defn g ([x] x) ([x y] (+ x y))) (g 10 20)"
+           "(defn h [a & more] (count more)) (h 1 2 3 4)"
+           # empty rest is nil (Clojure): count 0, first nil (prints "")
+           "(defn h [a & more] (count more)) (h 1)"
+           "(defn h [a & more] (first more)) (h 1)"
+           "(defn h [a & more] (first more)) (h 1 2 3)"
+           "(defn h [a & more] (reduce + a more)) (h 1 2 3 4)"
+           "(defn h [a & more] (reduce + a more)) (apply h [1 2 3 4])"
+           # self-call from one arity to another, then recur within it
+           "(defn f ([n] (f n 0)) ([n acc] (if (zero? n) acc (recur (- n 1) (+ acc n))))) (f 5)"
+           "((fn r [& xs] (if (seq xs) (+ (first xs) (apply r (rest xs))) 0)) 1 2 3)"]
+  (let [[code out err] (d/run-on-chez ctx src)
+        want (cli-oracle src)]
+    (ok (string "arity: " src) (and (= code 0) (= out want))
+        (string "chez=" out " janet=" want " | " err))))
+
 # 4) perf signal: emitted fib(30) in-Scheme timing (excludes Chez startup), to
 #    track against the spike ceiling (hand-Scheme fib ~5ms). Informational — the
 #    jolt-truthy? wrapper (~3x) and flonum modeling are known Phase-4 levers.