fleetd #668: drop counts from the javadoc that the new case made wrong

The claim-2 banner said validateAll reaches seven of eight validators. With
the validateLeadRollover case added it reaches all of them, so the banner was
false. Two more places said 'today's six' and were already stale at eight.

Removed the '1491 tests, 0 failures' parenthetical: a measurement in a comment
goes stale on its own, and the suite is far past that number. The count that
readers must keep correct still lives in the Set.of, which is where the
surrounding javadoc already points them.

fleetd/src/test/java/dev/ltms/fleet/config/FleetConfigValidateAllTest.java

@@ -44,11 +44,11 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
  *       seventh validator just to exercise the claim.</li>
  *   <li>{@link #validateAllReachesEveryOneOfTodaysRealValidators()} proves {@link
  *       FleetConfig#validateAll()} itself is wired to that same generic mechanism and genuinely
- *       reaches every one of today's eight real validators — reusing the exact minimal failing
+ *       reaches every one of today's real validators — reusing the exact minimal failing
  *       configurations {@code FleetConfigTest} already established for each one directly, plus a
  *       dedicated fixture for {@link FleetConfig#validateLeadRollover()}, which no other test
  *       drives through {@code validateAll()} — so a single call to {@code validateAll()} is shown
- *       to reproduce every one of those eight failures.</li>
+ *       to reproduce every one of those failures.</li>
  * </ol>
  *
  * <p>Together with the direct-{@code Fleetd.main}-invocation tests in {@code
@@ -58,10 +58,10 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
  * a test in this module.
  *
  * <p><b>What is NOT pinned, measured rather than assumed.</b> Reverting {@link
- * FleetConfig#validateAll()} to a hardcoded list of today's six method calls leaves the whole
- * suite green (measured at review: 1491 tests, 0 failures). Nothing ties {@code validateAll()} to
+ * FleetConfig#validateAll()} to a hardcoded list of today's method calls leaves the whole
+ * suite green. Nothing ties {@code validateAll()} to
  * the generic sweep — claim 1 proves {@link FleetConfig#invokeAllValidators} is generic, and claim
- * 2 proves {@code validateAll()} reaches today's six, and a hardcoded list satisfies both. So the
+ * 2 proves {@code validateAll()} reaches today's validators, and a hardcoded list satisfies both. So the
  * reflective sweep is a convenience, not the guarantee. The guarantee is {@link
  * #fleetConfigDeclaresExactlyTheseValidatorsToday()}: it fails the moment any validator is added
  * or removed, which forces whoever changes the set to look at this file.
@@ -210,7 +210,7 @@ class FleetConfigValidateAllTest {
                         + "name) must all be skipped");
     }
 
-    // ── Claim 2: FleetConfig.validateAll() is wired to that mechanism and reaches seven of eight today ──
+    // ── Claim 2: FleetConfig.validateAll() is wired to that mechanism and reaches every validator ──
 
     /**
      * Reflectively enumerates {@link FleetConfig}'s own public, no-arg, void {@code validateXxx()}
@@ -275,11 +275,11 @@ class FleetConfigValidateAllTest {
     }
 
     /**
-     * The heart of claim 2: for every one of today's eight real validators, a minimal file that
+     * The heart of claim 2: for every one of today's real validators, a minimal file that
      * fails ONLY that one — the exact fixtures {@code FleetConfigTest} uses to test each validator
      * directly, or a dedicated minimal fixture where no other test drives that validator through
      * {@code validateAll()} — must also fail through {@link FleetConfig#validateAll()}. If a
-     * future edit to {@code validateAll()} silently dropped one of these eight from the sweep
+     * future edit to {@code validateAll()} silently dropped one of these from the sweep
      * (e.g. a typo'd name filter), exactly one of them would start passing when it must not.
      *
      * <p>This is the single place that proves {@code validateAll()} reaches a given validator.