Chez Phase 1 (increment 3b): seq tier + dynamic IFn dispatch on the Chez RT

Brings up the seq layer on the Chez runtime. host/chez/seq.ss adds one
lazy-capable node (cseq) that models Clojure's list, cons, and lazy seq -
all print as (...), all sequential-= to each other and to vectors. seq
coerces any seqable (vector/map/set/string/list/seq/nil) to a cseq or nil;
the empty seq is a distinct value printing () (rest of a 1-elem coll is ()
not nil, seq of empty is nil). Leaf ops: first/rest/next/seq/cons/list,
reverse/last, map/filter/remove/reduce/into, range/take/drop/concat/apply,
keys/vals, plus nth/peek/pop extended over seqs. map/filter/reduce apply
their fn arg through jolt-invoke, so a procedure, keyword, or collection all
work as the fn.

Dynamic IFn dispatch: a keyword/vector/coll held in a local (let binding or
fn param) and called as a fn now routes through the jolt-invoke fallback
(procedure? -> apply; keyword/coll -> lookup). The emitter only routes a
:local callee that isn't a known procedure - a named fn's self-recursion
name stays a direct call, so the fib hot path is untouched. Closes the 3
ex-known IFn divergences.

emit.janet: seq/pred ops added to native-ops with arity gates; value-position
clojure.core refs resolve to the RT procedure (native-ops names one for each),
with +/-/*// routed to flonum-coercing wrappers so higher-order arithmetic
((reduce + [])) keeps the all-double model. values.ss: cross-type sequential
=/hash so a vector and a list of the same elements are jolt= and hash alike.
rt.ss: printer learns seqs; top-level nil prints as the empty string (jolt -e
str-style). Fixed latent bug: (conj nil ...) now builds a list, not a vector.

Gates: emit-test 69/69 (fib/mandelbrot/collections/seq/IFn parity vs the jolt
oracle, fib(30) ~24ms unchanged). Subset probe 433/436 -> 595/595 compiled,
0 divergences (was 3 known), 2060/2655 out of subset. Full run-tests green
(125 files, conformance + suites included).

host/chez/collections.ss

@@ -192,6 +192,9 @@
 (define (jolt-conj1 coll x)
   (cond ((pvec? coll) (pvec-conj coll x))   ; nil is a valid vector/set element
         ((pset? coll) (pset-conj coll x))
+        ;; a list/seq conjs by PREPENDING (seq.ss: cseq / empty-list)
+        ((cseq? coll) (cseq-realized x coll))
+        ((empty-list-t? coll) (cseq-realized x jolt-nil))
         ((pmap? coll)
          (cond ((jolt-nil? x) coll)                                   ; (conj m nil) = m
                ((pmap? x) (pmap-fold x (lambda (k v m) (pmap-assoc m k v)) coll))   ; merge
@@ -199,11 +202,10 @@
                 (pmap-assoc coll (pvec-nth-d x 0 jolt-nil) (pvec-nth-d x 1 jolt-nil)))
                (else (error 'conj "conj on a map expects a [k v] pair or a map"))))
         (else (error 'conj "unsupported collection"))))
-;; (conj nil a b ...) builds a list in Clojure, conj prepending -> (b a). We have
-;; no list type until inc 3b; a reversed pvec is = to that list (sequential =).
+;; (conj nil a b ...) builds a list in Clojure, conj prepending -> (b a).
 (define (jolt-conj coll . xs)
   (if (jolt-nil? coll)
-      (make-pvec (list->vector (reverse xs)))
+      (fold-left jolt-conj1 jolt-empty-list xs)
       (fold-left jolt-conj1 coll xs)))
 
 (define jolt-get
@@ -225,11 +227,13 @@
                              (if (and (fx>=? i 0) (fx<? i (vector-length v))) (vector-ref v i)
                                  (error 'nth "index out of bounds"))))
              ((string? coll) (string-ref coll i))
+             ((or (cseq? coll) (empty-list-t? coll)) (seq-nth coll i #f jolt-nil))
              (else (error 'nth "unsupported collection")))))
     ((coll i d)
      (let ((i (->idx i)))
        (cond ((pvec? coll) (pvec-nth-d coll i d))
              ((string? coll) (if (and (fx>=? i 0) (fx<? i (string-length coll))) (string-ref coll i) d))
+             ((or (cseq? coll) (empty-list-t? coll)) (seq-nth coll i #t d))
              (else d))))))
 
 ;; jolt models every number as a double, so a count is a flonum — else
@@ -241,6 +245,9 @@
           ((pset? coll) (pset-count coll))
           ((string? coll) (string-length coll))
           ((jolt-nil? coll) 0)
+          ((empty-list-t? coll) 0)
+          ((cseq? coll) (let loop ((s coll) (n 0))   ; walk (forces a finite seq)
+                          (if (jolt-nil? s) n (loop (jolt-seq (seq-more s)) (fx+ n 1)))))
           (else (error 'count "uncountable")))))
 
 (define (jolt-assoc1 coll k v)
@@ -272,12 +279,19 @@
         ((pmap? coll) (fx=? 0 (pmap-cnt coll)))
         ((pset? coll) (fx=? 0 (pset-count coll)))
         ((string? coll) (fx=? 0 (string-length coll)))
+        ((empty-list-t? coll) #t)
+        ((cseq? coll) #f)                            ; a cseq is non-empty by construction
         (else (error 'empty? "unsupported collection"))))
 
 (define (jolt-peek coll)
-  (cond ((pvec? coll) (pvec-peek coll)) ((jolt-nil? coll) jolt-nil) (else (error 'peek "unsupported collection"))))
+  (cond ((pvec? coll) (pvec-peek coll))
+        ((or (cseq? coll) (empty-list-t? coll)) (jolt-first coll))   ; list peek = first
+        ((jolt-nil? coll) jolt-nil) (else (error 'peek "unsupported collection"))))
 (define (jolt-pop coll)
-  (cond ((pvec? coll) (pvec-pop coll)) (else (error 'pop "unsupported collection"))))
+  (cond ((pvec? coll) (pvec-pop coll))
+        ((cseq? coll) (jolt-rest coll))                              ; list pop = rest
+        ((empty-list-t? coll) (error 'pop "can't pop empty list"))
+        (else (error 'pop "unsupported collection"))))
 
 ;; ============================================================================
 ;; equality / hash hooks called from values.ss (jolt=2 / jolt-hash)