stdlib: port clojure.data, rewrite clojure.zip; fix with-meta nil; add battery

clojure.data: ported from the ClojureScript impl (jolt-native equality-partition
fn instead of host-type protocol dispatch). Verified against Clojure's own
data-test (12/13 canonical; the 13th needs nil-valued-map support, jolt-c7h).
Used mapv over the reference's (doall (map …)) — jolt's lazy multi-coll map +
doall don't force as a reduce accumulator (jolt-dzh).

clojure.zip: jolt's was a broken custom reimplementation; replaced with a port of
real clojure.zip (metadata-based locs). Uses (nth loc …) instead of (loc …)
because meta-bearing vectors aren't invocable as fns (jolt-vh5).

core: with-meta now accepts nil metadata (Clojure allows (with-meta x nil)); it
crashed calling keys on nil. This is what unblocked zip's make-node.

New vendored battery (test/clojure-stdlib/, from clojurust's suite with fixtures
corrected to match real Clojure): walk 34, zip 33, data 61 all clean; edn guarded
at 43 (still a stub — jolt-b7y). Conformance 218/218 all modes; full suite green.

test/integration/clojure-stdlib-suite-test.janet

@@ -0,0 +1,60 @@
+# Vendored stdlib-namespace battery (jolt-0mb).
+#
+# clojure.test suites for stdlib namespaces beyond clojure.core, vendored from
+# clojurust's clojure-test-suite fork (test/clojure-stdlib/, with corrected
+# fixtures where the upstream expectations disagreed with real Clojure). Each
+# file runs in the shared per-file worker; we guard a minimum pass count so a
+# regression is caught and improvements (e.g. finishing clojure.edn) can raise
+# the floor.
+
+(def files
+  # [relative-path  min-pass  must-be-clean?]
+  [["clojure/walk_test/walk.cljc"            34 true]
+   ["clojure/zip_test/zip.cljc"              33 true]
+   ["clojure/data_test/diff.cljc"            61 true]
+   # clojure.edn is still a stub (no opts/:eof arity, broken set/nil handling);
+   # tracked separately. Guard its current passing subset so it can't regress.
+   ["clojure/edn_test/read_string.cljc"      43 false]])
+
+(def root "test/clojure-stdlib")
+(def per-file-timeout 6)
+
+(defn- run-file [path]
+  (def proc (os/spawn ["janet" "test/integration/suite-worker.janet" path] :p {:out :pipe}))
+  (def out (proc :out))
+  (var data nil)
+  (def ok (try
+            (ev/with-deadline per-file-timeout
+              (set data (ev/read out 0x10000))
+              (os/proc-wait proc) true)
+            ([err] false)))
+  (when (not ok)
+    (protect (os/proc-kill proc true))
+    (protect (ev/with-deadline 2 (os/proc-wait proc))))
+  (protect (:close out))
+  (if (and ok data) (string data) nil))
+
+(defn- counts [s]
+  (var r nil)
+  (each line (string/split "\n" (or s ""))
+    (when (string/has-prefix? "@@COUNTS " line)
+      (let [p (string/split " " (string/trim line))]
+        (when (= 4 (length p)) (set r [(scan-number (p 1)) (scan-number (p 2)) (scan-number (p 3))])))))
+  r)
+
+(var failures 0)
+(each [rel min-pass clean?] files
+  (def path (string root "/" rel))
+  (def c (counts (run-file path)))
+  (if (nil? c)
+    (do (++ failures) (printf "FAIL %s: no result (crash/timeout)" rel))
+    (let [[p f e] c]
+      (printf "  %-34s pass=%d fail=%d err=%d" rel p f e)
+      (when (< p min-pass)
+        (++ failures) (printf "FAIL %s: pass %d < baseline %d" rel p min-pass))
+      (when (and clean? (or (pos? f) (pos? e)))
+        (++ failures) (printf "FAIL %s: expected clean, got %d fail / %d err" rel f e)))))
+
+(if (pos? failures)
+  (do (printf "clojure-stdlib-suite: %d failure(s)" failures) (os/exit 1))
+  (print "clojure-stdlib-suite: OK"))