Contract fixes from the baseline audit; every residual suite failure traced

Auditing the remaining cts baseline for R7 exposed real contract gaps hiding
among the model residue — all fixed to reference behavior:

- stale no-ratio-era stubs: numerator/denominator now work over jolt's exact
  rationals (non-ratio is the Ratio cast failure); rational? includes decimals
- casts and pending: peek/pop demand an IPersistentStack (pop nil is nil),
  realized? demands an IPending (a plain list/range throws), transient demands
  an editable COLLECTION (non-colls throw; the RFC 0003 sorted/list/seq
  superset keeps the copy-on-write fallback), empty on a plain record throws
- nil and empties: (nth nil i) is nil, (nth nil i d) is d, a nil index is NPE,
  keys/vals of anything empty are nil, (conj nil) is nil
- lookups: contains? on a string is index-only (other keys IAE), get on an
  array is lenient (nth still throws), a VECTOR invocation has nth semantics
  (([1 2] 5) throws — call position and jolt-invoke both)
- into only transients editable collections; a PersistentQueue/sorted target
  folds through conj (RT's IEditableCollection split)
- numbers: number?/num accept BigDecimal, quot/rem throw on an Infinite/NaN
  quotient, even?/odd? demand integers
- ordering: keywords compare namespace-first with nil first (Symbol.compareTo)
- misc: run! honors reduced, eval self-evaluates non-form values, intern
  demands an existing namespace, counted? excludes strings, seqable? includes
  arrays, shuffle rejects maps, sort-by rejects a collection comparator,
  when-let demands one binding pair, case*/deftype*/letfn*/reify*/& are
  special symbols

Two mis-certified corpus rows fixed (they threw on the JVM too and hid in the
tolerated bucket): a raw \d string escape and duplicate literal map keys.

SPEC.md gains the baseline-traceability section: every one of the 146
remaining suite failures maps to a documented divergence (integer-box,
no-single-float, RFC 0003 transients, seq/chunking model, stm-refs,
parse-uuid strictness, vec-array adoption). cts baseline 5955 -> 6042 pass,
5 errors, 30 namespaces. 9 JVM-certified corpus rows.

host/chez/java/bigdec.ss

@@ -334,6 +334,11 @@
 (set! jolt-zero? (let ((prev jolt-zero?)) (lambda (x) (if (jbigdec? x) (jbd-zero? x) (prev x)))))
 (set! jolt-pos? (let ((prev jolt-pos?)) (lambda (x) (if (jbigdec? x) (jbd-pos? x) (prev x)))))
 (set! jolt-neg? (let ((prev jolt-neg?)) (lambda (x) (if (jbigdec? x) (jbd-neg? x) (prev x)))))
+;; a BigDecimal IS a number (java.lang.Number): extend the number? native so the
+;; predicate — and everything defined over it (num, =='s guard) — accepts it.
+;; The compiled fast paths test Chez number? directly and are unaffected.
+(set! jolt-number? (let ((prev jolt-number?)) (lambda (x) (if (jbigdec? x) #t (prev x)))))
+(def-var! "clojure.core" "number?" jolt-number?)
 (def-var! "clojure.core" "inc" jolt-inc)
 (def-var! "clojure.core" "dec" jolt-dec)
 (def-var! "clojure.core" "zero?" jolt-zero?)

host/chez/java/natives-array.ss

@@ -115,10 +115,11 @@
                  (let ((v (jolt-array-vec c)) (j (exact (na-idx i))))
                    (if (and (>= j 0) (< j (vector-length v))) (vector-ref v j) d))
                  (%na-nth c i d)))))
+(def-var! "jolt.host" "array-value?" (lambda (x) (if (jolt-array? x) #t jolt-nil)))
 (define %na-get jolt-get)
 (set! jolt-get
   (case-lambda
-    ((c k)   (if (jolt-array? c) (jolt-nth c k) (%na-get c k)))
+    ((c k)   (if (jolt-array? c) (jolt-nth c k jolt-nil) (%na-get c k)))
     ((c k d) (if (jolt-array? c) (jolt-nth c k d) (%na-get c k d)))))
 ;; aset (overlay) writes through jolt.host/ref-put! — mutate the slot, return arr.
 ;; count/nth/seq/get above are NATIVE-OPS (inlined at call sites), so aget/alength/