Chez Phase 3 inc7: corpus on the Chez-hosted analyzer + a 50x-faster gate

Point the Chez-HOSTED analyzer at the full parity corpus (read -> analyze ->
emit -> eval, all on Chez, no Janet) and close the divergences so the
self-hosted compiler is faithful: 0 divergences, 2159/2494 pass.

Keystone: the on-Chez emitter ran with prelude-mode off, so every call to a
non-native clojure.core fn tripped the "unsupported stdlib fn" out-of-subset
guard. The zero-Janet spine always has the full prelude loaded, so turn
prelude mode on in compile-eval.ss (22% -> 84% pass on a sample).

Faithfulness fixes (each was the Chez host/reader diverging from the Janet
analyzer; fixed in the keeper, not the seed):
- emit-const read a char's codepoint via (get v :ch) — the Janet rep; on Chez a
  char is native. Route through a new form-char-code host-contract fn (41 cases).
- next over a lazy seq returned the empty-list terminator (truthy), not nil, so
  butlast and other (if (next s) ...) loops ran one step too far — broke
  some->/some->>/cond->>.
- reader: radix literals (2r1010/16rFF/36rZ), #^ deprecated metadata, ^meta on
  collections (lowers to a runtime with-meta form like the Janet reader),
  map-literal source order (values eval left-to-right), and nested syntax-quote
  over a literal collapses at read time.
- keyword "a/b" splits into ns/name like the seed (destructure {:keys [x/y]}).
- form-syntax-quote-lower implemented on Chez (was a throwing stub).

7 divergences allowlisted: the same print-method-multimethod / host-class set
the prelude gate defers. 328 crashes remain = shared runtime breadth (host
interop, missing core fns, eval/load-string) deferred to Phase 4 / jolt-r8ku,
not compiler faithfulness.

Gate + speedup: test/chez/run-corpus-zero-janet.janet (floor 2159). Its batched
runner (driver/eval-corpus-zero-janet) runs every case in ONE chez process —
load the runtime once, guard + reset the user namespace per case — instead of a
fresh process per case: 1379s -> 1.6s.

spine-test 35/35; Janet gate 151/0; prelude parity 2295/2494 unchanged, 0 new
divergences.

host/chez/seq.ss

@@ -78,7 +78,11 @@
     (if (jolt-nil? s) jolt-empty-list
         (let ((m (seq-more s))) (if (jolt-nil? m) jolt-empty-list m)))))
 (define (jolt-next x)                  ; nil when the rest is empty
-  (let ((s (jolt-seq x))) (if (jolt-nil? s) jolt-nil (seq-more s))))
+  ;; next = (seq (rest x)): the rest must be RE-SEQ'd so an empty tail collapses to
+  ;; nil. seq-more on a lazy seq (e.g. map's) forces to jolt-empty-list, which is
+  ;; truthy — returning it raw made (next 1-elem-lazy-seq) non-nil, so butlast and
+  ;; other (if (next s) ...) loops over a lazy seq ran one step too far.
+  (let ((s (jolt-seq x))) (if (jolt-nil? s) jolt-nil (jolt-seq (seq-more s)))))
 ;; Only the HEAD cell carries the list marker — (rest a-list)/(next a-list) return
 ;; the unmarked tail, so they are seqs and not list?, matching the seed (which
 ;; makes rest-of-a-list a non-list seq). cons/list/reverse/conj therefore mark