Fix general gaps the hiccup suite shook out

Six correctness fixes, each a general gap (not hiccup-specific):

- deftype is not a map. jolt treated every deftype instance as a map
  (map?/record?/seqable over its fields); in Clojure only a defrecord is
  map-like, a bare deftype is an opaque object. defrecord now marks its type;
  map?/record?/coll?/seq/empty? gate on it, while a deftype implementing a
  collection interface still dispatches through its methods.

- cross-ns extend-protocol on an imported deftype. register-method built the
  type tag from the *calling* ns + bare name, so (extend-protocol P Raw …) in
  one ns missed a Raw value defined in another. A simple-name index resolves
  the bare name to the type's real tag (local ns still wins).

- str vs print. str of a collection is its readable form (nested strings
  quoted: (str ["x"]) => ["x"]); print leaves them raw. jolt defined print
  as str, conflating the two. Split via a __print1 seam.

- clojure.test thrown? now honors the exception hierarchy (instance?), so
  (thrown? IllegalArgumentException …) matches an ArityException subclass.

- java.net.URI is value-equal (= and hash by string form).

- clojure.walk/macroexpand-all was missing; an unresolved qualified var made
  the analyzer report "Unknown class walk".

deftype/defrecord + print are seed sources, re-minted. hiccup 365->381 of its
own suite; the rest are charset-encoding / var-meta niches.

host/chez/java/io.ss

@@ -605,6 +605,14 @@
         (cons "hashCode" (lambda (u) (string-hash (uri-field u 'string))))
         (cons "equals" (lambda (u o) (and (jhost? o) (string=? (jhost-tag o) "uri")
                                           (string=? (uri-field u 'string) (uri-field o 'string)))))))
+;; (= u1 u2) is value equality by string form (the .equals method above only
+;; serves explicit (.equals …)); hash matches so a URI works as a map key / set
+;; member (ring/hiccup compare (URI. "/") values).
+(define (uri-jhost? x) (and (jhost? x) (string=? (jhost-tag x) "uri")))
+(register-eq-arm! (lambda (a b) (or (uri-jhost? a) (uri-jhost? b)))
+                  (lambda (a b) (and (uri-jhost? a) (uri-jhost? b)
+                                     (string=? (uri-field a 'string) (uri-field b 'string)))))
+(register-hash-arm! uri-jhost? (lambda (x) (string-hash (uri-field x 'string))))
 ;; str / pr-str of a uri -> its string form.
 (register-str-render! (lambda (x) (and (jhost? x) (string=? (jhost-tag x) "uri")))
                       (lambda (x) (uri-field x 'string)))