perf(fsst): count training candidates by code in flat arrays, not HashMaps (#395)

Counts still tallied candidates with two HashMaps even after #393's
allocation fixes, paying a hash computation, bucket lookup, and
equals() per bump. The Rust reference's Counter (spiraldb/fsst)
counts by code in flat arrays with zero hashing and zero boxing.

Ported the same shape: codes 0..254 are real trained-symbol codes
(resolved through the current Compressor's own symbol table), codes
255..510 are escape pseudo-codes for literal bytes — a fixed,
dense space regardless of how many symbols are actually trained in
any one generation, so counts1/counts2 need no per-generation
resizing. A BitSet per array tracks which slots this generation
touched; only the touched bits are cleared between generations, not
the (much larger) count arrays, mirroring Counter's own
bitmap-gated design. CompressorBuilder now threads one Counts
instance across all five generations of a train() call instead of
allocating fresh ones.

Matcher.longestMatch already returns a code (Matcher.codeOf); this
also fixes the redundancy #393's finding #4 flagged, where that code
was computed and then thrown away in favor of re-deriving an
identity from packed bytes plus length.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01P4ijFsGW1MHEcGiu26vNzi

Author: dfa1

fsst/src/main/java/io/github/dfa1/vortex/fsst/CompressorBuilder.java

@@ -61,12 +61,15 @@ public Compressor train(byte[][] rows) {
         if (sample.chunkCount() == 0) {
             return compressor;
         }
+        // Reused across every generation instead of allocating fresh count arrays five times over
+        // (issue #395).
+        TrainingGeneration.Counts counts = new TrainingGeneration.Counts();
         for (int gen = 0; gen < GENERATIONS; gen++) {
             boolean finalGeneration = gen == GENERATIONS - 1;
             int chunkLimit = sample.chunkCountForGeneration(gen);
             int fractionNumerator = Sample.SAMPLE_FRACTION_NUMERATORS[gen];
             List<Symbol> symbols = TrainingGeneration.run(
-                    compressor, sample, chunkLimit, fractionNumerator, finalGeneration);
+                    compressor, sample, chunkLimit, fractionNumerator, finalGeneration, counts);
             // Reuse compressor's own (now fully consumed) matcher arrays instead of allocating a
             // fresh ~288 KB pair of tables on every one of the five generations (issue #393 #7).
             compressor = Compressor.rebuild(symbols, compressor);