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/rt.ss

@@ -12,6 +12,7 @@
 
 (load "host/chez/values.ss")
 (load "host/chez/collections.ss")
+(load "host/chez/seq.ss")
 
 ;; --- rt arithmetic / logic shims (named in emit.janet's native-ops) ----------
 (define (jolt-inc x) (+ x 1))
@@ -53,6 +54,10 @@
 (define (jolt-char->string c)
   (string-append "\\" (case c ((#\newline) "newline") ((#\space) "space") ((#\tab) "tab")
                         ((#\return) "return") (else (string c)))))
+;; Program-final printer: jolt's `-e` is str-style at the top level, where a
+;; bare nil renders as the empty string (a nil ELEMENT inside a collection still
+;; prints "nil", which jolt-pr-str handles).
+(define (jolt-final-str x) (if (jolt-nil? x) "" (jolt-pr-str x)))
 (define (jolt-pr-str x)
   (cond
     ((jolt-nil? x) "nil")
@@ -72,4 +77,10 @@
     ((pset? x) (string-append "#{" (jolt-str-join (pset-fold x (lambda (e a) (cons (jolt-pr-str e) a)) '())) "}"))
     ((pmap? x) (string-append "{" (jolt-str-join
                  (pmap-fold x (lambda (k v a) (cons (string-append (jolt-pr-str k) " " (jolt-pr-str v)) a)) '())) "}"))
+    ;; lists / cons / lazy seqs all print as (...) — forces a finite seq.
+    ((empty-list-t? x) "()")
+    ((cseq? x) (string-append "(" (jolt-str-join
+                 (let loop ((s x) (acc '()))
+                   (if (jolt-nil? s) (reverse acc)
+                       (loop (jolt-seq (seq-more s)) (cons (jolt-pr-str (seq-first s)) acc))))) ")"))
     (else (format "~a" x))))