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.

jolt-core/clojure/core/20-coll.clj

@@ -219,7 +219,8 @@
 ;; compiler emit/inference path) — see predicates.ss.
 (defn ratio? [x]
   (and (number? x) (jolt.host/exact? x) (jolt.host/rational-type? x) (not (integer? x))))
-(defn rational? [x] (and (number? x) (jolt.host/exact? x)))
+(defn rational? [x]
+  (or (and (number? x) (jolt.host/exact? x)) (decimal? x)))
 ;; No first-class Class objects: class names are symbols the evaluator handles in
 ;; instance?/new positions, never values — so nothing is a class.
 (defn class? [x] false)
@@ -274,7 +275,8 @@
     (loop [i 0 s (seq coll)]
       (if (and s (< i n)) (recur (inc i) (next s)) i))))
 
-(defn run! [proc coll] (reduce (fn [_ x] (proc x) nil) nil coll) nil)
+;; the reducing fn returns proc's result, so a Reduced from proc short-circuits
+(defn run! [proc coll] (reduce (fn [_ x] (proc x)) nil coll) nil)
 
 (defn completing
   ([f] (completing f identity))
@@ -457,7 +459,8 @@
 (defn sequential? [x] (or (vector? x) (seq? x)))
 (defn associative? [x] (or (map? x) (vector? x)))
 (defn counted? [x]
-  (or (vector? x) (map? x) (set? x) (list? x) (string? x)))
+  ;; a String is not Counted on the JVM (count works via CharSequence, not O(1))
+  (or (vector? x) (map? x) (set? x) (list? x)))
 (defn indexed? [x] (vector? x))
 ;; sorted? is defined by the next tier (25-sorted) — declared here so this
 ;; tier compiles (forward references are analysis errors).
@@ -465,7 +468,7 @@
 
 (defn reversible? [x] (or (vector? x) (sorted? x)))
 (defn seqable? [x]
-  (or (nil? x) (coll? x) (string? x)))
+  (if (or (nil? x) (coll? x) (string? x) (jolt.host/array-value? x)) true false))
 
 (defn boolean? [x] (or (true? x) (false? x)))
 (defn double? [x] (and (number? x) (not (integer? x))))