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.

jolt-core/jolt/ir.clj

@@ -118,7 +118,10 @@
       (= op :recur)  (assoc node :args (mapv f (get node :args)))
       (= op :fn)     (assoc node :arities (mapv (fn [a] (assoc a :body (f (get a :body))))
                                                 (get node :arities)))
-      (= op :def)    (assoc node :init (f (get node :init)))
+      (= op :def)    (let [n (assoc node :init (f (get node :init)))]
+                       (if (get node :meta-expr)
+                         (assoc n :meta-expr (f (get node :meta-expr)))
+                         n))
       (= op :host-call) (assoc node :target (f (get node :target))
                                     :args (mapv f (get node :args)))
       (= op :host-new) (assoc node :args (mapv f (get node :args)))
@@ -159,7 +162,8 @@
       (= op :loop) (f (reduce (fn [a b] (f a (nth b 1))) acc (get node :bindings)) (get node :body))
       (= op :recur) (reduce f acc (get node :args))
       (= op :fn) (reduce (fn [a ar] (f a (get ar :body))) acc (get node :arities))
-      (= op :def) (if (get node :init) (f acc (get node :init)) acc)
+      (= op :def) (let [a (if (get node :init) (f acc (get node :init)) acc)]
+                    (if (get node :meta-expr) (f a (get node :meta-expr)) a))
       (= op :host-call) (reduce f (f acc (get node :target)) (get node :args))
       (= op :host-new) (reduce f acc (get node :args))
       (= op :try)