feat: run the real clojure.tools.logging (defmacro/syntax-quote/ns + host shims)

Pivot from a jolt reimplementation to running the upstream library verbatim.
Vendors the real clojure/tools/logging.clj; jolt provides the backend and the
host primitives it needs. Language features (broadly useful for real Clojure
libs), all covered in 3-mode conformance + spec suites:

- defmacro: multi-arity dispatch (jolt-q8l) and a docstring + attr-map + params
  head (jolt-qnr) — the 4-arity log macro and every level macro need these.
- syntax-quote resolves an alias-qualified symbol to its target ns (jolt-9av),
  so a macro template (impl/get-logger) resolves at the use site.
- the ns macro unwraps ^{:map} metadata on the ns name (jolt-8w2 workaround,
  matching def/defn/defmacro).
- a namespace object self-evaluates, so ~*ns* can be spliced into a template.

Host shims (ported from / modeled on clojure where applicable):
- clojure.string/trim-newline (ported, CharSequence interop -> count/subs)
- agent/send-off/send (minimal synchronous stubs; jolt has no thread pool/STM)
- clojure.lang.LockingTransaction/isRunning -> false
- a minimal clojure.pprint (pprint/with-pprint-dispatch/code-dispatch, for spy)
- clojure.tools.logging.impl: a jolt stderr LoggerFactory backend (the library's
  designed pluggable extension point)

docs/libraries.md lists tools.logging; grammar.ebnf metadata note clarified.
Conformance 355/355 x3 modes; full jpm test gate green.

jolt-core/clojure/core/00-syntax.clj

@@ -110,7 +110,12 @@
 ;; then. Its body resolves fn/map/reduce/cond at EXPANSION time, by which point all
 ;; of 00-syntax has loaded, so using them here is fine.
 (defmacro ns [nm & clauses]
-  (let [calls (reduce
+  ;; ^{:map} metadata on the ns name reads as a (with-meta sym {...}) form, not an
+  ;; annotated symbol (jolt-8w2). Real libraries put :author/:doc there
+  ;; (clojure.tools.logging), so unwrap to the bare symbol; jolt does not track
+  ;; namespace metadata, so the map is dropped.
+  (let [nm (if (and (seq? nm) (= 'with-meta (first nm))) (second nm) nm)
+        calls (reduce
                 (fn [acc clause]
                   (if (seq? clause)
                     (let [head (first clause) args (rest clause)]

jolt-core/clojure/core/50-io.clj

@@ -177,3 +177,30 @@
 (defmethod print-method :jolt/chan [c w]
   (.write w "#<channel>")
   nil)
+
+;; Minimal synchronous agent shim. jolt has no thread pool or STM, so this is
+;; enough for libraries that hold an agent but don't depend on asynchronous
+;; dispatch (e.g. clojure.tools.logging's *logging-agent*, which only sends from
+;; within a transaction — never the case here, so it always logs directly). An
+;; agent is an atom; send/send-off apply the action immediately. NOT concurrent.
+(defn agent
+  "Creates an agent (an atom on jolt — synchronous, no async dispatch)."
+  [state & _opts]
+  (atom state))
+
+(defn send-off
+  "Apply (action state & args) to the agent's state immediately; return the agent."
+  [a f & args]
+  (apply swap! a f args)
+  a)
+
+(defn send
+  "Like send-off on jolt (no separate thread pool)."
+  [a f & args]
+  (apply swap! a f args)
+  a)
+
+(defn agent-error
+  "jolt agents never enter an error state."
+  [_a]
+  nil)