Match Clojure's lazy seq realization model

jolt's seq layer realized one element ahead of Clojure, so a side-effecting
lazy seq ran its producer too eagerly. Four changes bring it in line:

- rest is Clojure's more(): it returns the tail without realizing it. An
  unforced tail (vector / string / lazy-seq cell) comes back as a deferred
  seq, so (rest (iterate f x)) does not call f. next still realizes one.
- iterate applies f lazily, inside the tail thunk, so (first (iterate f x))
  is x with no call to f (clojure.lang.Iterate parity).
- take realizes exactly n: the last element terminates without touching the
  rest, instead of forcing one more element of the source.
- an empty realized lazy seq is still a sequence value, printing "()" not
  "nil" (a JVM LazySeq is never nil).

Also: the map transducer's step fn now takes multiple inputs
([result input & inputs]) so a multi-collection transduce applies f across
all of them. Fixes medley's join/window/sequence-padded laziness and
multi-input transducer tests (now 293/293). The rest change also fixed a
latent overrun in distinct/dedupe over a map's empty tail.

iterate is a seed source, re-minted.

host/chez/natives-seq.ss

@@ -17,13 +17,16 @@
 ;; call routes through jolt-invoke. A `reduced` step stops the fold — reduce-seq
 ;; (seq.ss) already short-circuits on a jolt-reduced.
 ;; ============================================================================
+;; The map transducer's step fn supports multiple inputs ([result input & inputs]),
+;; so a multi-collection sequence/transduce — or medley's sequence-padded, which
+;; calls (f acc i1 i2 …) — applies f across all of them: (rf result (apply f inputs)).
 (define (td-map f)
   (lambda (rf)
     (lambda a
       (case (length a)
         ((0) (jolt-invoke rf))
         ((1) (jolt-invoke rf (car a)))
-        (else (jolt-invoke rf (car a) (jolt-invoke f (cadr a))))))))
+        (else (jolt-invoke rf (car a) (apply jolt-invoke f (cdr a))))))))
 (define (td-filter pred)
   (lambda (rf)
     (lambda a