Run core.memoize's test suite on jolt

Shaking out clojure.core.memoize (207 assertions, 0 fail) cleared several
general gaps:

- deref/@ on a deftype or reify implementing clojure.lang.IDeref dispatches to
  its deref method (RetryingDelay / make-derefable).
- deftype mutable fields (^:unsynchronized-mutable / ^:volatile-mutable) are
  read live: a set! within a method is observed by a later read in the same
  invocation, not the entry-time capture. Needed for double-checked locking.
  Immutable fields stay let-bound. Field reads rewrite to (.-field inst) with
  lexical-shadow tracking.
- def metadata values are evaluated, like Clojure: ^{:k (f)} stores (f)'s
  result and ^{:af some-fn} the fn. :tag stays a literal hint.
- try dispatches catch clauses by class in order via the exception supertype
  hierarchy; a non-matching value re-throws, an untyped host condition is caught
  by a RuntimeException/Exception/Throwable clause. Previously the last clause
  won and the class was ignored.
- locking takes a real per-object monitor (recursive Chez mutex) now that
  futures/agents/threads share one heap; it was a no-op.
- supers/ancestors reflect a small modeled JVM interface hierarchy, so
  (ancestors (class f)) yields Runnable/Callable (core.memoize's arg check).
- AssertionError / Error constructors.

JOLT_FEATURES is gone from the docs: it isn't read anywhere on Chez, and the
reader already includes :clj in its default feature set. RFC 0002's
{:jolt :default} design was reverted in the reader; docs now match the code.

Raises the SCI floor 205 -> 210.

host/chez/host-static-classes.ss

@@ -456,7 +456,8 @@
   '("Throwable" "Exception" "RuntimeException" "IllegalArgumentException" "IllegalStateException"
     "InterruptedException" "UnsupportedOperationException" "IOException" "NumberFormatException"
     "ArithmeticException" "NullPointerException" "ClassCastException" "IndexOutOfBoundsException"
-    "FileNotFoundException" "UnsupportedEncodingException" "EOFException" "java.io.EOFException"))
+    "FileNotFoundException" "UnsupportedEncodingException" "EOFException" "java.io.EOFException"
+    "Error" "AssertionError"))
 
 ;; ---- URLEncoder / URLDecoder (www-form-urlencoded) --------------------------
 (define (url-unreserved? b)
@@ -742,3 +743,42 @@
 
 ;; (jolt.host/table? x) — is x a host tagged-table?
 (def-var! "jolt.host" "table?" (lambda (x) (if (htable? x) #t #f)))
+
+;; --- minimal JVM class/interface ancestry -----------------------------------
+;; A handful of libraries reflect over the class hierarchy — e.g. core.memoize
+;; validates its first argument with (some #{IFn AFn Runnable Callable}
+;; (ancestors (class f))). jolt models a class as its name string and has no
+;; reflection, so supers/ancestors return nothing on their own. This table gives
+;; the common interfaces the direct supers the JVM reports, and the overlay's
+;; supers/ancestors fold it in. Keyed by canonical class name; value = direct
+;; supers. Extend as more interfaces are exercised.
+(define class-supers-tbl (make-hashtable string-hash string=?))
+(define (reg-class-supers! name supers) (hashtable-set! class-supers-tbl name supers))
+(reg-class-supers! "clojure.lang.IFn" '("java.lang.Runnable" "java.util.concurrent.Callable"))
+(reg-class-supers! "clojure.lang.AFn" '("clojure.lang.IFn" "java.lang.Runnable" "java.util.concurrent.Callable"))
+(reg-class-supers! "clojure.lang.AFunction" '("clojure.lang.AFn" "clojure.lang.IFn" "clojure.lang.Fn"
+                                              "java.lang.Runnable" "java.util.concurrent.Callable"))
+
+;; transitive closure of direct supers (set semantics via an accumulator list)
+(define (class-ancestors-list name)
+  (let loop ((pending (hashtable-ref class-supers-tbl name '())) (seen '()))
+    (cond ((null? pending) (reverse seen))
+          ((member (car pending) seen) (loop (cdr pending) seen))
+          (else (loop (append (hashtable-ref class-supers-tbl (car pending) '()) (cdr pending))
+                      (cons (car pending) seen))))))
+
+;; (jolt.host/class-supers name) / (jolt.host/class-ancestors name) — a jolt seq of
+;; super / ancestor class-name strings, or nil when jolt models no hierarchy for it.
+(def-var! "jolt.host" "class-supers"
+  (lambda (x)
+    (let ((name (class-key x)))
+      (if (and name (hashtable-contains? class-supers-tbl name))
+          (list->cseq (hashtable-ref class-supers-tbl name '()))
+          jolt-nil))))
+(def-var! "jolt.host" "class-ancestors"
+  (lambda (x)
+    (let ((name (class-key x)))
+      (if name
+          (let ((as (class-ancestors-list name)))
+            (if (null? as) jolt-nil (list->cseq as)))
+          jolt-nil))))