fix(scores): restore per-player high-score flow

The rewrite waited for the whole game to finish, selected only the maximum
player score, and sorted entries as ordinary unsigned integers. The original
checks each player immediately when their own last ball is lost and compares
scores by signed high word then unsigned low word.

Emit a candidate at each player elimination, prompt qualifying players with the
original `TDK Pinball Player` value, show the table, and then either resume the
next player or return to attract mode. Preserve source table order on import and
insert only strictly qualifying scores with the original word-wise comparator;
keep JSON as the host persistence representation.

Test Plan:
- `cargo test --all-targets` -- passed, 60 tests
- `cargo clippy --all-targets -- -D warnings` -- passed
- `rumdl check tdkpin-rs/CHANGELOG.md tdkpin-rs/RECONSTRUCTION.md` -- passed
- `git diff --cached --check` -- passed

tdkpin-rs/src/app.rs

@@ -1,7 +1,9 @@
 use crate::{
     assets::Assets,
     game::{Controls, Event, Game, Nudge},
-    persistence::{HighScore, Language, Persistence, SavedData, insert_high_score},
+    persistence::{
+        HighScore, Language, Persistence, SavedData, insert_high_score, qualifies_high_score,
+    },
     table::BUMPERS,
 };
 use macroquad::prelude::*;
@@ -191,10 +193,23 @@ impl App {
         let events = self.game.as_mut().map_or_else(Vec::new, |game| {
             game.update(get_frame_time(), self.saved.settings.speed, controls)
         });
+        let mut high_score_candidate = None;
         for event in events {
+            if let Event::HighScoreCandidate(score) = event {
+                high_score_candidate = Some(score);
+            }
             self.play_event(event);
         }
 
+        if let Some(score) = high_score_candidate
+            && qualifies_high_score(&self.saved.high_scores, score)
+        {
+            self.pending_score = score;
+            "TDK Pinball Player".clone_into(&mut self.name);
+            self.screen = Screen::NameEntry;
+            return;
+        }
+
         if self.game.as_ref().is_some_and(|game| game.finished) {
             self.finish_game();
         }
@@ -207,26 +222,9 @@ impl App {
     }
 
     fn finish_game(&mut self) {
-        self.pending_score = self
-            .game
-            .as_ref()
-            .and_then(|game| game.players.iter().map(|player| player.score).max())
-            .unwrap_or(0);
-        let qualifies = self.saved.high_scores.len() < 10
-            || self
-                .saved
-                .high_scores
-                .last()
-                .is_some_and(|entry| self.pending_score > entry.score);
-        if qualifies {
-            self.name.clear();
-            self.screen = Screen::NameEntry;
-        } else {
-            self.game = None;
-            self.return_screen = Screen::Attract;
-            self.screen = Screen::HighScores;
-        }
-        self.assets.play(2020, self.saved.settings.sounds);
+        self.game = None;
+        self.return_screen = Screen::Attract;
+        self.screen = Screen::HighScores;
     }
 
     fn update_help(&mut self) {
@@ -315,8 +313,12 @@ impl App {
                 },
             );
             self.save();
-            self.game = None;
-            self.return_screen = Screen::Attract;
+            if self.game.as_ref().is_some_and(|game| game.finished) {
+                self.game = None;
+                self.return_screen = Screen::Attract;
+            } else {
+                self.return_screen = Screen::Playing;
+            }
             self.screen = Screen::HighScores;
         }
     }