Chunk range/map/filter to match JVM Clojure

range, map, and filter were fully element-by-element lazy, so
(map f (range 1 50)) realized one element per first/nth where JVM
Clojure realizes a whole 32-element chunk. range is a chunked
LongRange on the JVM and map/filter are chunk-preserving, so the
observable side-effect timing differed.

Following clojure.lang.LongRange, ChunkedCons, ChunkBuffer and
core.clj, this adds a crest field to the cseq record and a
cseq-chunked constructor modeling ChunkedCons (a standalone chunk
pvec, an offset, and the after-chunk seq). The chunk accessors move
to seq.ss next to the representation they read. map/filter/remove
take a chunked branch when the source is chunked, realizing the whole
chunk and chunk-cons'ing it onto a lazy rest, so their output is
itself chunked and chained transforms each batch by 32. Bounded range
is now an eager chunked seq, and the reduce fast path flows through a
ChunkedCons rest. The chunk-buffer/chunk/chunk-cons builder API in
natives-array.ss now produces a real ChunkedCons.

Single-arg (range), multi-coll map, and plain lazy seqs stay
element-by-element, like the JVM.

Adds a lazy / chunking suite to the corpus that observes realization
timing via an atom counter: first over a chunked map realizes 32,
crossing a chunk boundary realizes 49, chained maps batch [32 32],
filter applies the predicate to the whole first block, and a plain
lazy seq still realizes one element at a time. Two cases that
documented the old over-laziness now assert the JVM value of 32 and
were dropped from the allowlist. certify against JVM Clojure 1.12.3
reports 0 new and 0 stale divergences.

host/chez/java/natives-array.ss

@@ -91,51 +91,18 @@
   (let ((s (bitwise-and (exact (floor x)) #xffff))) (if (>= s #x8000) (- s #x10000) s)))
 
 ;; --- chunked seqs -----------------------------------------------------------
-;; A vector's seq is a REAL chunked-seq: (seq v) carries its backing vector +
-;; element index (seq.ss cseq-vec), so chunked-seq? is true and chunk-first hands
-;; out a 32-element block (a pvec slice) while chunk-rest is the seq at the next
-;; block boundary — the Clojure/CLJS ChunkedSeq contract (chunk-first ++
-;; chunk-rest == the seq). The eager buffer model (chunk-buffer/chunk-append/
-;; chunk) builds a plain cseq; chunk-cons/first/rest fall back to seq ops over it.
-(define na-chunk-size 32)
+;; The chunked-seq accessors (chunked-seq? / chunk-first / chunk-rest / chunk-next)
+;; live in seq.ss with the cseq core they read; here we only bind them plus the
+;; chunk-builder API (clojure.lang.ChunkBuffer + chunk-cons). chunk-buffer collects
+;; appended items, chunk seals them into a pvec chunk, and chunk-cons prepends that
+;; chunk onto a rest seq as a real ChunkedCons (cseq-chunked) — empty chunk == just
+;; the rest, like clojure.core/chunk-cons.
 (define-record-type jolt-chunkbuf (fields (mutable items)) (nongenerative jolt-chunkbuf-v1))
 (define (na-chunk-buffer cap) (make-jolt-chunkbuf '()))
 (define (na-chunk-append b x) (jolt-chunkbuf-items-set! b (append (jolt-chunkbuf-items b) (list x))) b)
-(define (na-chunk b) (list->cseq (jolt-chunkbuf-items b)))
-(define (na-chunk-cons chunk rest) (jolt-concat chunk rest))
-;; backing (vector . end-of-block index) for a vector-seq cell, or #f.
-(define (na-vblock s)
-  (and (cseq? s) (cseq-cvec s)
-       (let* ((v (cseq-cvec s)) (i (cseq-ci s)))
-         (cons v (fxmin (fx+ i na-chunk-size) (pvec-count v))))))
-(define (na-chunked-seq? x) (and (na-vblock x) #t))
-;; Copy the block [i, end) straight out of the pvec trie's 32-element leaf node
-;; (pv-chunk-for is O(log n)). na-chunk-size == pv-width and blocks are 32-aligned,
-;; so a block is exactly one leaf; the rare non-aligned window crossing a leaf
-;; boundary falls back to per-index reads. Flattening the whole backing vector
-;; per block (pvec-v) made chunk-first O(n), so walking a vector chunk-by-chunk
-;; was O(n^2).
-(define (na-chunk-first s)
-  (let ((vb (na-vblock s)))
-    (if vb
-        (let* ((pv (car vb)) (i (cseq-ci s)) (end (cdr vb)) (len (fx- end i))
-               (node (pv-chunk-for pv i)) (off (fxand i pv-mask)))
-          (if (fx<=? (fx+ off len) (vector-length node))
-              (make-pvec (vec-copy-range node off (fx+ off len)))
-              (let ((out (make-vector len)))
-                (let loop ((j 0))
-                  (if (fx<? j len)
-                      (begin (vector-set! out j (pvec-nth-d pv (fx+ i j) jolt-nil)) (loop (fx+ j 1)))
-                      (make-pvec out))))))
-        (jolt-first s))))               ; eager-buffer fallback
-(define (na-chunk-rest s)
-  (let ((vb (na-vblock s)))
-    (if vb (if (fx>=? (cdr vb) (pvec-count (car vb))) jolt-empty-list (vec->seq (car vb) (cdr vb)))
-        (jolt-rest s))))
-(define (na-chunk-next s)
-  (let ((vb (na-vblock s)))
-    (if vb (if (fx>=? (cdr vb) (pvec-count (car vb))) jolt-nil (vec->seq (car vb) (cdr vb)))
-        (jolt-next s))))
+(define (na-chunk b) (make-pvec (list->vector (jolt-chunkbuf-items b))))
+(define (na-chunk-cons chunk rest)
+  (if (fx=? 0 (pvec-count chunk)) rest (cseq-chunked chunk 0 rest)))
 
 ;; --- extend the collection dispatchers to see a jolt-array ------------------
 (define %na-count jolt-count)