core: the last seven missing-portable vars — coverage gap closed (jolt-brh)

The dashboard's missing-portable category is now EMPTY (was 35 when the issue
was filed; this session's io/leaf work had already landed most of them).
The final seven:

- extenders — ctx-capturing clojure.core fn over the protocol type-registry:
  the type-tags implementing a protocol, as symbols; nil when none
- find-keyword — keyword: jolt keywords have no intern table, so it always
  finds (babashka makes the same call)
- inst-ms* — the raw Inst method; one inst representation, so = inst-ms
- read+string — over the 50-io readers, which now expose :buf and :fill-fn;
  returns [form exact-text-consumed], EOF throws or yields [eof-value ""]
  with the 3-arity, works for string AND stdin readers
- with-local-vars — fresh free-standing var cells (__local-var seam) bound as
  locals; var-get/var-set work on any cell
- with-open — canonical recursive expansion closing through the __close seam:
  a map-like value's :close fn or a host file (no .close interop here);
  nested closes run inner-first, finally runs on throw
- with-precision — body evaluates with precision/:rounding accepted and
  ignored (doubles, no BigDecimal context) — documented divergence

30 new spec rows (test/spec/missing-vars-spec.janet); coverage.md
regenerated: implemented+tested 426 -> 433, missing-portable 7 -> 0.
Gate: jpm exit 0, all tests passed.

jolt-core/clojure/core/30-macros.clj

@@ -73,6 +73,29 @@
                       [] (partition 2 bindings))]
     `(with-redefs-fn (hash-map ~@pairs) (fn [] ~@body))))
 
+;; Fresh free-standing var cells bound as locals; read/write with
+;; var-get/var-set. The cells come from the host seam __local-var.
+(defmacro with-local-vars [bindings & body]
+  (let [binds (reduce (fn [acc p] (conj (conj acc (first p)) `(__local-var ~(second p))))
+                      [] (partition 2 bindings))]
+    `(let [~@binds] ~@body)))
+
+;; Canonical recursive expansion; closing goes through the host seam __close
+;; (a map-like value's :close fn or a host file — no .close interop here).
+(defmacro with-open [bindings & body]
+  (if (zero? (count bindings))
+    `(do ~@body)
+    `(let [~(first bindings) ~(second bindings)]
+       (try
+         (with-open ~(vec (drop 2 bindings)) ~@body)
+         (finally (__close ~(first bindings)))))))
+
+;; jolt numbers are doubles — there is no BigDecimal math context, so the
+;; precision (and optional :rounding mode) is accepted and ignored.
+(defmacro with-precision [precision & exprs]
+  (let [body (if (= :rounding (first exprs)) (drop 2 exprs) exprs)]
+    `(do ~@body)))
+
 (defmacro with-bindings [binding-map & body]
   `(with-bindings* ~binding-map (fn [] ~@body)))