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.

host/chez/async.ss

@@ -21,20 +21,39 @@
 (define (jolt-async-sliding-buffer n)  (make-async-buffer n 'sliding))
 
 ;; --- channels ---------------------------------------------------------------
-;; items: a FIFO list of (value . box); box is #f for a buffered value or a 1-slot
-;; vector for an unbuffered rendezvous put (set #t when taken, waking the putter).
+;; items: an amortized-O(1) FIFO held as a mutable #(out in len) — `out` is the
+;; front (pop from its head), `in` holds pushed entries reversed onto it, `len` is
+;; the count (an append-to-a-list FIFO is O(n) per push and O(n) to measure).
+;; Each entry is (value . box); box is #f for a buffered value or a 1-slot vector
+;; for an unbuffered rendezvous put (set #t when taken, waking the putter).
 ;; cap 0 + kind 'unbuffered = rendezvous; cap>0 with kind fixed/dropping/sliding.
 (define-record-type async-chan
   (fields mu cv (mutable items) cap kind (mutable closed?) (mutable xrf))
   (nongenerative async-chan-v1))
 
-(define (ac-qlen ch) (length (async-chan-items ch)))
-(define (ac-qempty? ch) (null? (async-chan-items ch)))
-(define (ac-qpush! ch entry) (async-chan-items-set! ch (append (async-chan-items ch) (list entry))))
+(define (ac-qnew) (vector '() '() 0))
+(define (ac-qlen ch) (vector-ref (async-chan-items ch) 2))
+(define (ac-qempty? ch) (fx=? 0 (vector-ref (async-chan-items ch) 2)))
+(define (ac-qpush! ch entry)
+  (let ((q (async-chan-items ch)))
+    (vector-set! q 1 (cons entry (vector-ref q 1)))
+    (vector-set! q 2 (fx+ 1 (vector-ref q 2)))))
+(define (ac-qfront! q)                  ; ensure `out` is non-empty: out := reverse in
+  (when (null? (vector-ref q 0))
+    (vector-set! q 0 (reverse (vector-ref q 1)))
+    (vector-set! q 1 '())))
 (define (ac-qpop! ch)
-  (let ((e (car (async-chan-items ch))))
-    (async-chan-items-set! ch (cdr (async-chan-items ch))) e))
-(define (ac-qdrop-oldest! ch) (async-chan-items-set! ch (cdr (async-chan-items ch))))
+  (let ((q (async-chan-items ch)))
+    (ac-qfront! q)
+    (let ((out (vector-ref q 0)))
+      (vector-set! q 0 (cdr out))
+      (vector-set! q 2 (fx- (vector-ref q 2) 1))
+      (car out))))
+(define (ac-qdrop-oldest! ch)
+  (let ((q (async-chan-items ch)))
+    (ac-qfront! q)
+    (vector-set! q 0 (cdr (vector-ref q 0)))
+    (vector-set! q 2 (fx- (vector-ref q 2) 1))))
 
 ;; enqueue honoring the buffer kind (used by the transducer step + buffered puts).
 (define (ac-buf-give! ch v)
@@ -54,7 +73,7 @@
           ((null? (cdr args)) (car args))                     ; completion
           (else (ac-buf-give! ch (cadr args)) (car args)))))  ; step
 
-(define (ac-make cap kind xrf) (make-async-chan (make-mutex) (make-condition) '() cap kind #f xrf))
+(define (ac-make cap kind xrf) (make-async-chan (make-mutex) (make-condition) (ac-qnew) cap kind #f xrf))
 
 ;; (chan) | (chan n) | (chan buf) | (chan n|buf xform)
 (define (jolt-async-chan . args)