Dead-code removal, perf fixes, deterministic seed emission

Round 1 (correctness + dead code):
- Fix duplicate java.util.HashMap registration in host-static.ss: the alist
  impl shadowed the hashtable ctor while leaving the hashtable methods bound,
  so .keySet/.values/.remove/.clear crashed. Drop the alist version.
- Delete jolt-core/jolt/reader.clj: a 463-line dead duplicate reader, never
  required or compiled (the live reader is host/chez/reader.ss) and drifted.
- Remove dead defs: ir/rt + :rt op + unused ir/op; the Janet branch in
  clojure.edn/drain-reader; a shadowed first clojure.string/trim-newline;
  io.ss jolt-char-array + the reader def-var (both shadowed by natives-array);
  concurrency.ss jolt-future-done?*; compile-eval.ss jolt-analyze-emit.

Round 2 (perf + determinism):
- emit-quoted-map-value / quoted sets now emit sorted by emitted text instead
  of host-hash order, which isn't stable across Chez versions (jolt-8479).
- jolt-into folds through a transient, so into/vec/mapv/filterv onto a vector
  are O(n) instead of O(n^2).
- deps resolve-deps walks its queue with an index cursor (was subvec-per-pop).
- async channel and agent action queues use amortized-O(1) FIFOs; ArrayList is
  backed by a growable vector (O(1) add/get) instead of a list.

jolt-core/jolt/deps.clj

@@ -83,22 +83,26 @@
   declarations from every dep's deps.edn. `base-dir` resolves :local/root and is
   replaced by a dep's own root as the walk descends."
   [deps base-dir]
+  ;; queue grows by appending children at the tail; an index cursor walks it so
+  ;; each dequeue is O(1) (was (subvec (vec queue) 1) per pop -> O(n^2)).
   (loop [queue (mapv (fn [[c s]] [c s base-dir]) (seq deps))
+         i 0
          seen #{}
          roots []
          natives []]
-    (if (empty? queue)
+    (if (>= i (count queue))
       {:roots (distinct roots) :natives natives}
-      (let [[coord spec bd] (first queue)
-            queue (subvec (vec queue) 1)]
+      (let [[coord spec bd] (nth queue i)
+            i (inc i)]
         (if (contains? seen coord)
-          (recur queue seen roots natives)
+          (recur queue i seen roots natives)
           (let [root (coord-root coord spec bd)]
             (if (nil? root)
-              (recur queue (conj seen coord) roots natives)
+              (recur queue i (conj seen coord) roots natives)
               (let [edn (read-edn (str root "/deps.edn"))
                     child (mapv (fn [[c s]] [c s root]) (seq (:deps edn)))]
                 (recur (into queue child)
+                       i
                        (conj seen coord)
                        (into roots (dep-source-roots root))
                        (into natives (:jolt/native edn)))))))))))