CI: skip doxygen on Windows MINGW64 + extend stress-test budget

Two remaining failures from the previous run:

1. Windows MINGW64 timed out at the 6h ceiling. After my earlier
   check-readme CRLF fix unblocked that target, the next step on the
   make check-local pipeline (check-doxygen.sh -> make doxygen-run)
   wedged on a cmd.exe "Terminate batch job (Y/N)?" prompt produced
   by the autoconf-archive doxygen recipe under MSYS2/MINGW. The
   Linux lanes already exhaustively check the doxygen invariant, so
   drop doxygen+graphviz from the MINGW64 package list; check-doxygen
   detects the missing tool and self-skips (already designed for it).

2. route_table_concurrency cycles I and J failed under the valgrind
   memcheck lane with writer_ops=0 — the 500ms wall budget that the
   test relies on for at least one iteration is too tight when each
   register_path()/regex compile is running under heavy valgrind
   instrumentation. Keep the 500ms baseline but, if either counter
   is still zero, sleep in 100ms chunks up to a 30s ceiling. Normal
   lanes are unaffected (counters cross zero in well under 500ms);
   valgrind reliably converges within a couple seconds.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: etr

.github/workflows/verify-build.yml

@@ -388,7 +388,13 @@ jobs:
     - name: Install MinGW64 packages
       if: ${{ matrix.os-type == 'windows' && matrix.msys-env == 'MINGW64' }}
       run: |
-        pacman --noconfirm -S --needed mingw-w64-x86_64-{toolchain,libtool,make,pkg-config,libsystre,doxygen,gnutls,graphviz,curl}
+        # NB: doxygen + graphviz intentionally excluded — `make check-local`
+        # invokes scripts/check-doxygen.sh which spawns `make doxygen-run`,
+        # and the autoconf-archive-generated MINGW recipe hangs indefinitely
+        # waiting on a cmd.exe batch prompt (job timed out at the 6h ceiling
+        # in CI). The doxygen invariant is exhaustively checked by the Linux
+        # lanes; Windows just builds and tests the library here.
+        pacman --noconfirm -S --needed mingw-w64-x86_64-{toolchain,libtool,make,pkg-config,libsystre,gnutls,curl}
 
     - name: Install MSYS packages
       if: ${{ matrix.os-type == 'windows' && matrix.msys-env == 'MSYS' }}

test/integ/route_table_concurrency.cpp

@@ -117,10 +117,20 @@ LT_BEGIN_AUTO_TEST(route_table_concurrency_suite,
         });
     }
 
-    // Run for ~500ms. Long enough to cover several context-switch
-    // windows on a loaded box; short enough that `make check` stays
-    // under one second.
+    // Run for ~500ms baseline (long enough to cover several context-
+    // switch windows; short enough that `make check` stays under a
+    // second on a normal box). Then keep going in 100ms chunks until
+    // both counters are non-zero, up to a 30s safety ceiling — this
+    // keeps the test reliable on heavily-instrumented lanes such as
+    // valgrind/memcheck where a single register_path+regex-compile
+    // can take longer than the entire baseline window.
+    auto deadline =
+        std::chrono::steady_clock::now() + std::chrono::seconds(30);
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    while ((writer_ops.load() == 0 || reader_ops.load() == 0)
+           && std::chrono::steady_clock::now() < deadline) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
     stop.store(true, std::memory_order_relaxed);
     for (auto& t : threads) t.join();
 
@@ -202,7 +212,14 @@ LT_BEGIN_AUTO_TEST(route_table_concurrency_suite,
         });
     }
 
+    // Same baseline + valgrind-tolerant extension as Cycle I above.
+    auto deadline2 =
+        std::chrono::steady_clock::now() + std::chrono::seconds(30);
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    while ((writer_ops.load() == 0 || reader_ops.load() == 0)
+           && std::chrono::steady_clock::now() < deadline2) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
     stop.store(true, std::memory_order_relaxed);
     for (auto& t : threads) t.join();