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.

docs/host-interop.md

@@ -57,7 +57,10 @@ aren't implemented; a few are accepted but no-ops (noted inline).
   `.hashCode` `.equals` `.getClass` work on any value.
 - **`java.lang.Class`** — `forName` (throws a catchable `ClassNotFoundException`
   for a class jolt can't back, so `(try (Class/forName "opt.Dep") (catch …))`
-  dependency probes work).
+  dependency probes work). There is no reflection, but a few common interfaces
+  carry a modeled ancestry so `(supers c)` / `(ancestors c)` answer like the JVM —
+  e.g. `(ancestors (class f))` for a function yields `Runnable` and `Callable`,
+  the check `core.memoize` uses to validate a memoizable argument.
 
 ### Strings and text
 
@@ -138,8 +141,13 @@ aren't implemented; a few are accepted but no-ops (noted inline).
   `IllegalArgumentException` `IllegalStateException` `IOException`
   `NumberFormatException` `ArithmeticException` `NullPointerException`
   `ClassCastException` `IndexOutOfBoundsException` `FileNotFoundException`
-  `UnsupportedOperationException` and the common network exceptions, each with
-  the `(E.)` / `(E. msg)` / `(E. msg cause)` / `(E. cause)` constructors.
+  `UnsupportedOperationException` `Error` `AssertionError` and the common network
+  exceptions, each with the `(E.)` / `(E. msg)` / `(E. msg cause)` / `(E. cause)`
+  constructors. `try` dispatches its `catch` clauses by class in order, respecting
+  the exception supertype hierarchy (`(catch Exception e …)` catches a
+  `RuntimeException` but not an `Error`); a thrown value matching no clause
+  re-throws. An untyped host condition (e.g. from `(/ 1 0)`) is caught by a
+  `RuntimeException`/`Exception`/`Throwable` clause.
 
 What's deliberately absent: STM (`clojure.lang.LockingTransaction/isRunning`
 returns `false`), reflection, `gen-class`/`proxy` of Java classes, and