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/concurrency.ss

@@ -260,6 +260,12 @@
            (jolt-promise-deref-timed x (car opts) (cadr opts))))
       ((jolt-agent? x) (jolt-agent-state x))
       ((jolt-delay? x) (jolt-delay-force x))
+      ;; a record/reify implementing clojure.lang.IDeref: @x calls its `deref`
+      ;; method with the value itself as the leading `this`.
+      ((and (jrec? x) (find-method-any-protocol (jrec-tag x) "deref"))
+       => (lambda (m) (jolt-invoke m x)))
+      ((and (reified-methods x) (hashtable-ref (reified-methods x) "deref" #f))
+       => (lambda (m) (jolt-invoke m x)))
       (else (apply %pre-conc-deref x opts)))))
 
 ;; realized? for a future/promise/delay. Wrapped over the overlay version in
@@ -289,6 +295,26 @@
 (def-var! "clojure.core" "delay?" jolt-delay?)
 (def-var! "clojure.core" "deref" jolt-deref)
 
+;; --- object monitors (locking) ----------------------------------------------
+;; (locking obj body…) takes obj's monitor for the body — a real per-object lock
+;; now that futures/agents/threads share one heap. Each object gets a recursive
+;; Chez mutex (a thread may re-enter a monitor it already holds, like the JVM),
+;; held in an identity-keyed weak table so monitors are reclaimed with their
+;; objects. dynamic-wind releases on normal, exceptional, and continuation exit.
+(define monitor-table (make-weak-eq-hashtable))
+(define monitor-table-lock (make-mutex))
+(define (object-monitor obj)
+  (with-mutex monitor-table-lock
+    (or (hashtable-ref monitor-table obj #f)
+        (let ((m (make-mutex))) (hashtable-set! monitor-table obj m) m))))
+(define (jolt-with-monitor obj thunk)
+  (let ((m (object-monitor obj)))
+    (dynamic-wind
+      (lambda () (mutex-acquire m))
+      thunk
+      (lambda () (mutex-release m)))))
+(def-var! "jolt.host" "with-monitor" jolt-with-monitor)
+
 ;; --- cooperative thread interrupt -------------------------------------------
 ;; Chez has no force-kill, but its engine timer (set-timer + timer-interrupt-
 ;; handler, thread-local) is polled at procedure-call / loop back-edges — so a