Collection fns: JVM-faithful return types + laziness (#219)

A type-aware audit (~190 collection expressions vs reference Clojure) found four
divergences the corpus missed — value-equality (= [0 1] '(0 1)) hides type and
laziness differences. Fixed, with type-predicate + over-infinite corpus rows that
pin them.

- partition-all [n coll] built vector chunks; JVM chunks are seqs. (The [n step
  coll] arity was already correct, as is the partition-all transducer, whose
  chunks are vectors in JVM too.) Now builds seq chunks.
- replace always returned a vector (mapv) and was eager; JVM is type-preserving —
  a vector maps to a vector, any other seqable to a lazy seq.
- sequence eagerly realized its source (into-xform), so (first (sequence (map inc)
  (range))) hung. Rewrote as a transformer iterator: pull one input at a time,
  buffer the step outputs, emit lazily, run the completion to flush a stateful
  xform. eduction builds on it (lazy, no longer an eager vector).
- mapcat and (apply concat coll-of-colls) hung over an infinite source because
  jolt-apply seq->lists the trailing arg and mapcat seq->lists the map result.
  Added lazy-concat-seq (lazily flatten a seq of colls); mapcat uses it directly,
  and apply special-cases concat (its result is lazy) to route through it.

Docs: a cross-cutting return-type + laziness contract in docs/spec/09-core-library;
SPEC.md notes that = masks type/laziness so they need predicate / over-infinite
rows. EBNF is reader syntax only — unaffected.

Seed change (partition-all/replace/eduction are clojure.core overlay) -> re-mint;
selfhost holds. make test + shakesmoke + buildsmoke green, 0 new divergences.

Co-authored-by: Yogthos <yogthos@gmail.com>

host/chez/seq.ss

@@ -269,10 +269,25 @@
         ((null? (cdr colls)) (jolt-seq (car colls)))
         (else (concat2 (jolt-seq (car colls)) (lambda () (apply jolt-concat (cdr colls)))))))
 
-;; (apply f a b ... coll): spread the trailing seqable into the call.
+;; Lazily concatenate a (possibly infinite) SEQ of colls — what (apply concat ss)
+;; means, but without realizing ss. Pulls one coll at a time, concatenating it with
+;; a lazy tail, so mapcat / (apply concat …) over an infinite source stays lazy.
+(define (lazy-concat-seq ss)
+  (let ((s (jolt-seq ss)))
+    (if (jolt-nil? s)
+        jolt-empty-list
+        (jolt-concat (seq-first s)
+                     (jolt-make-lazy-seq (lambda () (lazy-concat-seq (seq-more s))))))))
+
+;; (apply f a b ... coll): spread the trailing seqable into the call. concat is
+;; special-cased: it produces a LAZY result, so spreading an infinite tail through
+;; a Scheme variadic (which must realize it) would hang — route to lazy-concat-seq,
+;; prepending any fixed leading colls.
 (define (jolt-apply f . args)
-  (let* ((r (reverse args)) (spread (seq->list (jolt-seq (car r)))) (fixed (reverse (cdr r))))
-    (apply jolt-invoke f (append fixed spread))))
+  (let* ((r (reverse args)) (tail (car r)) (fixed (reverse (cdr r))))
+    (if (eq? f jolt-concat)
+        (lazy-concat-seq (fold-right jolt-cons (jolt-seq tail) fixed))
+        (apply jolt-invoke f (append fixed (seq->list (jolt-seq tail)))))))
 
 ;; ============================================================================
 ;; numeric predicates / identity — usable in fn AND value position (map/filter).