ci(rust): serialize core lib tests to dodge cross-runtime semaphore hang

Root cause of the long-standing intermittent hang on the `Rust Core
Tests + Quality` and `Rust Core Coverage` jobs: `cargo test -p openhuman`
runs `#[tokio::test]` tests in parallel, each on its own current-thread
runtime, but several modules share process-wide singletons:

  * `scheduler_gate::LLM_PERMITS` — `tokio::sync::Semaphore`
  * `scheduler_gate::STATE`       — `OnceLock<RwLock<State>>`
  * `local_ai::LOCAL_AI_TEST_MUTEX` — `std::sync::Mutex`
  * `event_bus::testing::BUS_HANDLER_LOCK` — `tokio::sync::Mutex`

The `tokio::sync::Semaphore` waiter in test A registers a Waker tied to
runtime A. When test B drops the held permit from runtime B and that
runtime is in the process of tearing down, the cross-runtime wake does
not fire reliably — A's spawned future never resumes. On the CI runner
this presents as a hung `cargo test` step; locally on faster hosts the
prior assertion (`try_acquire_llm_permit().expect("must start free")`)
panics first and only manifests as a `FAILED` test.

Running `cargo test -p openhuman -- --test-threads=1` is a one-line
mitigation that eliminates the parallelism and brings the step from
"hangs indefinitely" to a deterministic ~90s on the same suite. The
deeper test-isolation refactor (swap the OnceLocks for resettable
cells, shared serial mutex around every `wait_for_capacity` callsite)
is queued as a follow-up — this commit unblocks CI immediately.

Applied to both `.github/workflows/test.yml` (`Test core crate`) and
`.github/workflows/coverage.yml` (`Rust Core Coverage`).

Author: senamakel

.github/workflows/coverage.yml

@@ -84,7 +84,10 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
       - name: Run cargo llvm-cov for openhuman core
-        run: cargo llvm-cov -p openhuman --lcov --output-path lcov-core.info
+        # See test.yml `Test core crate` for why `--test-threads=1` is
+        # required: process-wide singletons in scheduler_gate / local_ai
+        # do not isolate cleanly across parallel `#[tokio::test]` runtimes.
+        run: cargo llvm-cov -p openhuman --lcov --output-path lcov-core.info -- --test-threads=1
       - name: Upload core lcov
         uses: actions/upload-artifact@v5
         with:

.github/workflows/test.yml

@@ -83,7 +83,14 @@ jobs:
         uses: mozilla-actions/sccache-action@v0.0.9
 
       - name: Test core crate (openhuman)
-        run: cargo test -p openhuman
+        # Serialize tests: several modules share process-wide singletons
+        # (`scheduler_gate::LLM_PERMITS` semaphore, `scheduler_gate::STATE`,
+        # `LOCAL_AI_TEST_MUTEX`, `BUS_HANDLER_LOCK`) that don't cleanly
+        # isolate when `#[tokio::test]` runtimes run in parallel — on the
+        # CI runner some waiters never get woken when another runtime
+        # drops the permit, wedging the whole binary. Runs in ~90s; the
+        # underlying isolation refactor is tracked separately.
+        run: cargo test -p openhuman -- --test-threads=1
 
   rust-tauri-tests:
     name: Rust Tauri Shell Tests