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>

test/conformance/SPEC.md

@@ -35,6 +35,12 @@ the canonical, frozen contract**: it is what every runtime consumes, what
   disambiguates duplicate labels with ` (N)`).
 - Comparison is **value-equality** (`=`), never string/printed-form — so map/set
   iteration order never matters.
+- Because comparison is `=`, a **type** or **laziness** difference is invisible to a
+  plain value row: `(= [0 1] '(0 1))` is true, so a fn returning a vector where
+  Clojure returns a seq still passes. Pin those explicitly — container/element type
+  with a predicate row (`(seq? …)`, `(vector? …)`, `(every? seq? …)`), and laziness
+  with a `(take n (… (range)))` row over an infinite source (it hangs, not just
+  diverges, if the fn isn't lazy). The `seq / lazy over infinite` suite does both.
 - `:expected :throws` asserts evaluating `:actual` raises.
 
 ## The oracle: reference JVM Clojure