Chez Phase 0a+0b: value model + host-neutral contract gate

0a (host/chez/values.ss): Jolt value model on Chez — nil sentinel distinct from
#f/'(), interned keywords, ns+meta symbols, exactness-aware = and consistent
hash. Chez numeric tower gives ratios/bignums free. 33/33 tests.

0b (test/chez/): extract test/spec/*.janet defspec tables into corpus.edn (2655
cases, valid as both EDN and Janet data), and a runner that drives ANY jolt
binary via the CLI boundary with per-case subprocess isolation. Pluggable target
(JOLT_BIN) so the same corpus gates every host. Baseline vs Janet build/jolt:
2641/2655, 14 known CLI divergences allowlisted; gate fails only on NEW ones.

host/chez/values.ss

@@ -0,0 +1,74 @@
+;; Jolt value model on Chez Scheme — Phase 0a (jolt-cf1q.1).
+;;
+;; The irreducible value layer the self-hosted RT rests on. Maps Clojure's value
+;; types onto Chez natives where possible, and adds records only where Chez lacks
+;; a distinct type (nil sentinel, keywords, ns-bearing symbols). Loaded into an
+;; env that has already (import (chezscheme)); becomes a real library in Phase 1.
+;;
+;; Design notes:
+;; - nil is a UNIQUE sentinel, distinct from #f and '() (the classic Lisp-on-Lisp
+;;   trap). jolt false -> Chez #f, jolt true -> #t.
+;; - Chez's numeric tower IS Clojure's: long->exact integer, double->flonum,
+;;   ratio->exact rational, bigint->bignum. A windfall vs Janet (ratios/bignums
+;;   for free). Clojure `=` is exactness-aware: (= 1 1.0) is FALSE.
+
+;; --- nil ---------------------------------------------------------------------
+(define-record-type jolt-nil-t (fields) (nongenerative jolt-nil-v1))
+(define jolt-nil (make-jolt-nil-t))
+(define (jolt-nil? x) (jolt-nil-t? x))
+
+;; --- truthiness: only nil and false are falsey -------------------------------
+(define (jolt-truthy? x) (not (or (jolt-nil? x) (eq? x #f))))
+
+;; --- keywords: interned so identity works; optional namespace ----------------
+(define-record-type keyword-t (fields ns name khash) (nongenerative keyword-v1))
+(define keyword-table (make-hashtable string-hash string=?))
+(define (keyword-intern-key ns name) (string-append (or ns "") "/" name))
+(define (keyword ns name)
+  (let ((k (keyword-intern-key ns name)))
+    (or (hashtable-ref keyword-table k #f)
+        (let ((kw (make-keyword-t ns name (equal-hash k))))
+          (hashtable-set! keyword-table k kw)
+          kw))))
+(define (keyword? x) (keyword-t? x))
+
+;; --- symbols: ns + name + meta; NOT interned (meta varies), = by ns/name ------
+(define-record-type symbol-t (fields ns name meta) (nongenerative symbol-v1))
+(define (jolt-symbol ns name) (make-symbol-t ns name jolt-nil))
+(define (jolt-symbol/meta ns name meta) (make-symbol-t ns name meta))
+(define (jolt-symbol? x) (symbol-t? x))
+
+;; chars/strings: Chez natives (strings treated immutable).
+
+;; --- jolt equality (Clojure =) — scalars; collections land in Phase 2 --------
+(define (jolt=2 a b)
+  (cond
+    ((and (jolt-nil? a) (jolt-nil? b)) #t)
+    ((or  (jolt-nil? a) (jolt-nil? b)) #f)
+    ((and (number? a) (number? b))                 ; exactness-aware
+     (and (eq? (exact? a) (exact? b)) (= a b)))
+    ((and (keyword-t? a) (keyword-t? b)) (eq? a b)) ; interned
+    ((and (symbol-t? a) (symbol-t? b))
+     (and (equal? (symbol-t-ns a) (symbol-t-ns b))
+          (string=? (symbol-t-name a) (symbol-t-name b))))
+    ((and (char? a) (char? b)) (char=? a b))
+    ((and (string? a) (string? b)) (string=? a b))
+    ((and (boolean? a) (boolean? b)) (eq? a b))
+    (else (eq? a b))))
+(define (jolt= a . rest)
+  (let loop ((a a) (rest rest))
+    (cond ((null? rest) #t)
+          ((jolt=2 a (car rest)) (loop (car rest) (cdr rest)))
+          (else #f))))
+
+;; --- jolt hash — consistent with jolt= (for the HAMT in 0c / Phase 2) ---------
+(define (jolt-hash x)
+  (cond
+    ((jolt-nil? x) 0)
+    ((keyword-t? x) (keyword-t-khash x))
+    ((symbol-t? x) (equal-hash (cons (symbol-t-ns x) (symbol-t-name x))))
+    ((number? x) (if (exact? x) (equal-hash x) (equal-hash (cons 'inexact (inexact->exact x)))))
+    ((string? x) (string-hash x))
+    ((char? x) (char->integer x))
+    ((boolean? x) (if x 1 2))
+    (else (equal-hash x))))