Fix general divergences surfaced by clojure-test-suite

Five fixes shaken out by running jank-lang/clojure-test-suite:

- = short-circuits on identity like Util.equiv's k1 == k2, so (= s s) on an
  infinite lazy seq answers true instead of walking forever. Numbers keep the
  exactness-aware arm ((= ##NaN ##NaN) stays false like the JVM's).
- Calling a non-fn names the operator's CLASS in the ClassCastException, like
  the JVM — never the value, whose printed form may be unbounded: ((range))
  must throw, not hang rendering an infinite seq.
- realized? on a seq cell answers by its forced flag (the rest of a realized
  lazy chain is a cseq under jolt's seq model), and the overlay's unsupported-
  type error names the class, not the (possibly infinite) value.
- clojure.test/is dispatches a REGISTERED assert-expr method before its by-name
  inline paths, like clojure.test where the built-ins are just pre-registered
  methods — so an alias-qualified p/thrown? (the suite's portability helper)
  isn't captured by the built-in thrown? path, which read its body as a class.
- clojure.test tracks tests and fixtures per namespace: deftest records its
  defining ns, use-fixtures registers under the calling ns (no more cross-ns
  clobbering), (run-tests 'ns ...) runs only those namespaces like clojure.test,
  and each run-tests call prints/returns its own summary (global counters stay
  cumulative for the n-pass/n-fail harness API).

Re-mint (20-coll.clj is seed; prelude only). +2 JVM-certified corpus rows;
the clojure-test fixture pins the alias-qualified assert-expr, per-call
summaries, and ns filtering.

host/chez/seq.ss

@@ -257,12 +257,18 @@
      => (lambda (m) (apply jolt-invoke m f args)))
     ((and (reified-methods f) (hashtable-ref (reified-methods f) "invoke" #f))
      => (lambda (m) (apply jolt-invoke m f args)))
-    ;; calling a non-fn: a ClassCastException naming the operator, thrown via
-    ;; jolt-throw so it is catchable and carries the throw-site continuation for a
-    ;; stack trace.
+    ;; calling a non-fn: a ClassCastException naming the operator's CLASS (like
+    ;; the JVM's "class clojure.lang.LazySeq cannot be cast to ... IFn" — never
+    ;; the value, whose printed form may be unbounded: ((range)) must throw, not
+    ;; hang rendering an infinite seq). Thrown via jolt-throw so it is catchable
+    ;; and carries the throw-site continuation for a stack trace.
     (else (jolt-throw (jolt-host-throwable "java.lang.ClassCastException"
-                        (string-append (guard (e (#t "value")) (jolt-pr-str f))
-                                       " cannot be cast to clojure.lang.IFn"))))))
+                        (string-append
+                          "class "
+                          (guard (e (#t "value"))
+                            (let ((c (jolt-class-name f)))
+                              (if (string? c) c (jolt-pr-str f))))
+                          " cannot be cast to class clojure.lang.IFn"))))))
 
 ;; ============================================================================
 ;; chunked-seq accessors — the host side of the Clojure IChunkedSeq contract