Phase 5: true laziness — lazy transformers + deadlined harness

jolt-c09 (partial, Steps 0–2d complete).

Lazy combinator layer (Step 1):
- lazy-cons: build a LazySeq cell from val + rest-thunk (phm.janet)
- lazy-from: coerce any seqable to lazy view without forcing (core.janet)
- core-seq: check ls-first emptiness, not ls-seq realization (core.janet)

Lazy transformers (Steps 2a–2d):
Converted in Janet core.janet (lazy branches preserving transducer arities):
  drop-while, interpose, distinct, partition, partition-all,
  keep, keep-indexed, map-indexed, take-nth

Moved to Clojure overlay (jolt-core):
  interleave (20-coll.clj) — lazy multi-arity, matches Clojure
  mapcat (10-seq.clj) — transducer arity + standard (apply concat (apply map f colls))

Safety net (Step 0):
  test/support/lazy-eval.janet — subprocess worker for Clojure eval
  test/integration/lazy-infinite-test.janet — deadlined harness (os/spawn + 5s)

Multi-input map/mapcat tests (Step 2d):
  sequences-spec.janet +9 tests, verified against Clojure/CLJS references

Gates:
  lazy-infinite: 18/18 (mapcat on infinite inputs hangs — apply forces, needs Step 4)
  conformance: 229/229 ×3 (interpret/compile/self-host)
  specs: 32/32 files, 0 failures

test/spec/sequences-spec.janet

@@ -45,6 +45,12 @@
   ["map stops at shortest"  "[5 7]"        "(map + [1 2] [4 5 6])"]
   # nil elements are values, not end-of-seq: multi-coll map must not truncate.
   ["map keeps nil elements" "[[1 :a] [nil :b] [3 nil]]" "(map vector [1 nil 3] [:a :b nil])"]
+  ["map 3 colls"            "[12 15 18]"   "(map + [1 2 3] [4 5 6] [7 8 9])"]
+  ["map 3 colls shortest"   "[12 15]"      "(map + [1 2] [4 5 6] [7 8 9])"]
+  ["map 4 colls"            "[16 20]"      "(map + [1 2] [3 4] [5 6] [7 8])"]
+  ["map 3 colls nils"       "[[1 :a 10] [nil :b 20] [3 nil 30]]" "(map vector [1 nil 3] [:a :b nil] [10 20 30])"]
+  ["map empty coll"         "()"           "(map + [] [1 2 3] [4 5 6])"]
+  ["map lazy+concrete"      "[11 22 33]"   "(map + (map identity [1 2 3]) [10 20 30])"]
   ["map-indexed"            "[[0 :a] [1 :b]]" "(map-indexed vector [:a :b])"]
   ["mapv"                   "[2 3 4]"      "(mapv inc [1 2 3])"]
   ["filter"                 "[2 4]"        "(filter even? [1 2 3 4])"]
@@ -61,6 +67,10 @@
   ["reduce-kv on nil"       "0"           "(reduce-kv (fn [a k v] (+ a v)) 0 nil)"]
   ["reductions"             "[1 3 6]"     "(reductions + [1 2 3])"]
   ["mapcat"                 "[1 1 2 2]"   "(mapcat (fn [x] [x x]) [1 2])"]
+  ["mapcat two colls"       "[1 3 2 4]"   "(mapcat vector [1 2] [3 4])"]
+  ["mapcat three colls"     "[1 2 3]"     "(mapcat vector [1] [2] [3])"]
+  ["mapcat empty coll"      "()"          "(mapcat vector [] [1 2] [3 4])"]
+  ["mapcat seqs"            "[1 2 3 4]"   "(mapcat identity [[1 2] [3 4]])"]
   ["keep"                   "[1 3]"       "(keep (fn [x] (if (odd? x) x nil)) [1 2 3 4])"]
   ["some truthy"            "true"        "(some even? [1 2 3])"]
   ["some nil"              "nil"          "(some even? [1 3 5])"]