Chez Phase 3 inc6a: zero-Janet spine (analyzer + emitter on Chez), macro-free

Cross-compile jolt.ir + jolt.analyzer + jolt.backend-scheme to Scheme def-var!
forms via the existing Janet emit pipeline (driver/emit-compiler-image) and run
them ON CHEZ over a Scheme jolt.host impl. A macro-free Clojure expression now
compiles and runs with no Janet in the loop: read (reader.ss) -> analyze
(jolt.analyzer on Chez) -> IR -> emit (jolt.backend-scheme on Chez) -> eval.

host/chez/host-contract.ss is the jolt.host contract on Chez (the portable seam
the cross-compiled analyzer/emitter call): form-* over the Chez reader's forms,
resolve-global/compile-ns/host-intern!/late-bind? over the var-cell registry. ctx
is an opaque record carrying the compile ns. Native-op names are declare-var!'d
into clojure.core so +, *, <, ... classify as :var and the emitter's native-op
path lowers them. form-macro? is a #f stub and macro expansion / syntax-quote /
record hints are stubs for inc6b (runtime macros, jolt-r8ku).

host/chez/compile-eval.ss is the spine entry (read-string -> analyze -> emit ->
eval). driver gains emit-compiler-image / ensure-compiler-image (image caching)
and program-zero-janet / eval-zero-janet.

Two bugs fixed in the keeper, not reproduced:
- the Chez reader stores an unqualified symbol's ns as #f, but the analyzer tests
  (nil? ns); hc-sym-ns normalizes #f/'() -> jolt-nil. Without it every handled
  special (if/do/fn*) misanalyzed as a plain invoke.
- char (int->char) was missing from clojure.core on Chez; the emitter's
  chez-str-lit needs it for keyword/string consts. Added jolt-char to converters.ss.

Gate: test/chez/spine-test.janet 15/15 (Chez-hosted analyzer value == Janet-hosted
oracle through the same emitter/RT; only the analysis host differs). Full Janet
gate green (150 files). driver.janet is in the prelude fingerprint so the cache key
moved; prelude content is unchanged. jolt-chez fingerprint/ensure-prelude made
public for the test harness.

host/chez/compile-eval.ss

@@ -0,0 +1,28 @@
+;; compile-eval.ss (jolt-hs9n, Phase 3 inc6) — the zero-Janet compile spine.
+;;
+;; Ties together the cross-compiled compiler image (jolt.ir + jolt.analyzer +
+;; jolt.backend-scheme, loaded as def-var! forms) and the host contract
+;; (host-contract.ss) into a runtime entry: a Clojure source string is read by the
+;; Chez data reader, analyzed by the ON-CHEZ analyzer to IR, emitted to Scheme by
+;; the ON-CHEZ emitter, and eval'd — no Janet in the loop. This is the spine the
+;; stage2==stage3 bootstrap fixpoint (later increments) closes over.
+;;
+;; Loaded after host-contract.ss + the compiler image.
+
+(define jolt-ce-analyze (var-deref "jolt.analyzer" "analyze"))
+(define jolt-ce-emit (var-deref "jolt.backend-scheme" "emit"))
+(define jolt-ce-read (var-deref "clojure.core" "read-string"))
+
+;; Source string -> Scheme source string (read -> analyze -> emit, all on Chez).
+;; `ns` is the compile namespace unqualified symbols resolve against.
+(define (jolt-analyze-emit src ns)
+  (let* ((form (jolt-ce-read src))
+         (ctx (make-analyze-ctx ns))
+         (ir (jolt-ce-analyze ctx form)))
+    (jolt-ce-emit ir)))
+
+;; Source string -> value (compile on Chez, then eval the emitted Scheme in the
+;; top-level environment where rt.ss's runtime procedures live).
+(define (jolt-compile-eval src ns)
+  (eval (read (open-input-string (jolt-analyze-emit src ns)))
+        (interaction-environment)))