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/50-io.clj

@@ -19,7 +19,9 @@
   "A reader over string s (the with-in-str expansion calls this)."
   [s]
   (let [buf (atom s)]
-    {:read-line-fn
+    {:buf buf
+     :fill-fn nil
+     :read-line-fn
      (fn []
        (let [cur @buf]
          (when (pos? (count cur))
@@ -40,7 +42,13 @@
 (def ^:private stdin-buf (atom ""))
 
 (def ^:dynamic *in*
-  {:read-line-fn
+  {:buf stdin-buf
+   :fill-fn (fn []
+              (let [line (__stdin-read-line)]
+                (if (nil? line)
+                  false
+                  (do (swap! stdin-buf (fn [b] (str b line "\n"))) true))))
+   :read-line-fn
    (fn []
      (let [cur @stdin-buf]
        (if (pos? (count cur))
@@ -87,6 +95,27 @@
   `(binding [*in* (__string-reader ~s)]
      ~@body))
 
+;; Like read, and also returns the exact text consumed for the form (leading
+;; whitespace included). On EOF: throws, or returns [eof-value ""] when
+;; eof-error? is false.
+(defn read+string
+  ([] (read+string *in*))
+  ([stream] (read+string stream true nil))
+  ([stream eof-error? eof-value]
+   (let [buf (get stream :buf)
+         fill (get stream :fill-fn)]
+     (loop []
+       (let [s (deref buf)
+             r (__parse-next s)]
+         (if (nil? r)
+           (if (and fill (fill))
+             (recur)
+             (if eof-error?
+               (throw (ex-info "EOF while reading" {}))
+               [eof-value ""]))
+           (do (reset! buf (nth r 1))
+               [(nth r 0) (subs s 0 (- (count s) (count (nth r 1))))])))))))
+
 (defn line-seq
   "Returns the lines of text from rdr as a lazy sequence of strings, as by
   read-line. (Jolt extension kept from the old kernel stub: a plain string