perf(walker-gate): cache reachable set per flush invocation

The property-based walker gate (commit ce94475) replaced a tiny
class-name allowlist (Class::MOP/Moose/Moo) with a per-object flag
storedInPackageGlobal. This semantically correct change widened the
gate to fire on far more blessed objects -- DBIx::Class stores many
blessed instances (Schema, ResultSource, Storage::DBI) into package-
global hashes and uses weaken() liberally for back-refs, so most of
its objects now satisfy the gate at MortalList.flush().

Each gate fire ran ReachabilityWalker.isReachableFromRoots(target),
an O(globals) BFS. With N targets per flush, total cost was
O(N x globals) -- quadratic. Surfaced as a 100% CPU spin in DBI-
generated SQL dispatch code under HARNESS_OPTIONS=j4 parallel runs
(t/100populate.t, t/101populate_rs.t, t/100extra_source.t etc. never
completed; standalone runs stayed fast because their flush queues
are smaller).

Fix: compute the reachable set once per flush via the existing
ReachabilityWalker.walk() and reuse for O(1) membership lookups.
Cleared in the finally block so subsequent flushes recompute against
fresh global state.

Verified:
- DBIx::Class parallel-harness batch that previously hung now passes
  in 47s (16 tests, 327 subtests).
- DBIx::Class t/52leaks.t still passes (the leak-detection test the
  walker gate exists to protect).
- Moo 841/841, Moose 5/5, Template Toolkit 2660/2660 unchanged.
- make unit tests pass.

Generated with [Devin](https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: fglock

src/main/java/org/perlonjava/core/Configuration.java

@@ -33,7 +33,7 @@ public final class Configuration {
      * Automatically populated by Gradle/Maven during build.
      * DO NOT EDIT MANUALLY - this value is replaced at build time.
      */
-    public static final String gitCommitId = "6fe03a5c0";
+    public static final String gitCommitId = "0cdf8633e";
 
     /**
      * Git commit date of the build (ISO format: YYYY-MM-DD).
@@ -48,7 +48,7 @@ public final class Configuration {
      * Parsed by App::perlbrew and other tools via: perl -V | grep "Compiled at"
      * DO NOT EDIT MANUALLY - this value is replaced at build time.
      */
-    public static final String buildTimestamp = "Apr 29 2026 13:54:22";
+    public static final String buildTimestamp = "Apr 29 2026 15:54:11";
 
     // Prevent instantiation
     private Configuration() {

src/main/java/org/perlonjava/runtime/runtimetypes/MortalList.java

@@ -562,6 +562,23 @@ public static boolean suppressFlush(boolean suppress) {
             System.getenv("JPERL_GC_DEBUG") != null;
     private static boolean inAutoSweep = false;
 
+    // D-W6.18 perf: cached reachable-set, valid for the duration of a
+    // single flush() invocation. The walker BFS is O(globals); without
+    // this cache, calling it once per pending target turns flush into
+    // O(targets × globals). DBIC stresses this hard because many
+    // blessed objects are stored-in-package-global AND have weak refs
+    // (Schema/ResultSource back-refs) — every flush would re-walk the
+    // full global graph for each one. Computed lazily on first need.
+    private static Set<RuntimeBase> flushReachableCache = null;
+
+    private static boolean isReachableCached(RuntimeBase base) {
+        if (flushReachableCache == null) {
+            ReachabilityWalker w = new ReachabilityWalker();
+            flushReachableCache = w.walk();
+        }
+        return flushReachableCache.contains(base);
+    }
+
     public static void flush() {
         if (!active || pending.isEmpty() || flushing) return;
         flushing = true;
@@ -591,7 +608,7 @@ public static void flush() {
                     } else if (base.blessId != 0
                             && base.storedInPackageGlobal
                             && WeakRefRegistry.hasWeakRefsTo(base)
-                            && ReachabilityWalker.isReachableFromRoots(base)) {
+                            && isReachableCached(base)) {
                         // D-W6.18: property-based walker gate.
                         // Replaces the class-name heuristic
                         // (classNeedsWalkerGate). Object's lifetime is
@@ -616,6 +633,7 @@ public static void flush() {
             marks.clear(); // All entries drained; marks are meaningless now
         } finally {
             flushing = false;
+            flushReachableCache = null;
         }
         // Phase B2a: guarded auto-sweep.
         maybeAutoSweep();