test: give each test its own PredBat rather than sharing one (#5079)

Every registered test ran against a single PredBat built once at startup, so a
test that mutated instance state and did not restore it broke whichever
unrelated test happened to follow - depending only on the order they ran in.
That has produced a long series of order-dependent failures (#5079), each
previously fixed by hand-writing a snapshot/restore block naming the fields
that particular test touched.

Building the fixture per test removes the whole class instead. Measured on the
53 known-bad (culprit, victim) orderings collected so far: 53 of 53 fail before
this change, 0 of 53 after (with #5100, which fixes the one test that also
fails on its own).

The reason this was not done sooner appears to be an assumption that rebuilding
would be too slow. It is not - create_predbat() is about 22ms, and the full
suite measures 174s shared against 173s per-test, i.e. no measurable difference,
since the suite's cost is dominated by the prediction work inside the tests
rather than by fixture setup.

Also confirms the tests themselves are sound: all 316 pass when run individually
in their own process, so every ordering failure was shared-fixture contamination
rather than a test depending on an earlier one to set it up.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: chalfontchubby

apps/predbat/unit_test.py

@@ -819,6 +819,8 @@ def main():
         sys.exit(0)
 
     print("**** Starting Predbat tests ****")
+    # Used by the debug-file, random-scenario and profiling paths below. The registry test
+    # loop does not share this one - it builds a fresh instance per test (see GH#5079).
     my_predbat = create_predbat()
     print("**** Testing Predbat ****")
     failed = False
@@ -897,6 +899,13 @@ def main():
         # still running (or one that hung) is identified by its unmatched start stamp.
         print(f"**** Running: {name} - {desc} (start {time.strftime('%H:%M:%S')}) ****")
 
+        # Each test gets a PredBat of its own, so state an earlier test left behind cannot
+        # reach it. Sharing one instance across the whole run made a test that mutated it
+        # without restoring break whichever unrelated test happened to follow, depending on
+        # the order they ran in (GH#5079). create_predbat() costs about 22ms, which is lost
+        # in the noise of the suite as a whole.
+        my_predbat = create_predbat()
+
         start_time = time.time()
         test_failed = func(my_predbat)
         elapsed = time.time() - start_time