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/records-interop.ss

@@ -119,3 +119,26 @@
 ;; records.ss, so this set! sees the registry — forward refs resolve at call time.
 
 (def-var! "clojure.core" "instance-check" instance-check)
+
+;; Broad-catch fallback for catch-clause dispatch (analyze-try desugars
+;; (catch C e …) to (or (instance? C e) (__catch-broad? "C" e))). A jolt host
+;; condition or a raw raised value carries no jolt exception class, so instance?
+;; can't place it; a Clojure (catch C e) over such a value matches when C is
+;; RuntimeException (or a subclass) / Exception / Throwable — most host runtime
+;; errors are RuntimeExceptions. Typed throwables (ex-info, (SomeException. …)) are
+;; recognized by instance? as Throwable, so untyped? is false and they dispatch
+;; precisely through the instance? arm instead.
+(define throwable-type-sym (jolt-symbol #f "Throwable"))
+(define (simple-class-name nm)
+  (let loop ((i (- (string-length nm) 1)))
+    (cond ((< i 0) nm)
+          ((char=? (string-ref nm i) #\.) (substring nm (+ i 1) (string-length nm)))
+          (else (loop (- i 1))))))
+(define (jolt-catch-broad? nm v)
+  (and (not (instance-check throwable-type-sym v))
+       (let ((s (simple-class-name nm)))
+         (or (exception-isa? s "RuntimeException")
+             (string=? s "Exception")
+             (string=? s "Throwable")))))
+(def-var! "clojure.core" "__catch-broad?"
+  (lambda (nm v) (if (jolt-catch-broad? nm v) #t #f)))