Add multiplayer bots, typing languages, and rework the UI layout

Multiplayer
- Quick match: POST /api/multiplayer/quickmatch returns whichever room is
  still filling, or opens one. Players never see a room code; joining by
  code stays for racing specific people.
- Bots fill quick-match rooms after a short wait so a new game is never an
  empty lobby. They only ever join quick-match rooms, never a room opened
  by code. One or two per room, drawn from separate ~40 and ~80 WPM tiers so
  two bots are never near each other's pace, and they stall to correct
  mistakes rather than typing a clean straight line.
- Live player count via GET /api/multiplayer/online, shown on the
  Multiplayer control and under the main menu's Multiplayer button.
- Per-racer colours: you are the theme accent, opponents take distinct hues
  that stay the same from lobby to race.
- The countdown no longer holds the room lock for its full three seconds,
  which is what reset clients mid-countdown.

Typing languages
- 16 languages for the generated-word modes, each with its own
  high-frequency vocabulary rather than a translation of the English list.
- Picker in the top-right rail; non-English uses its own list at every
  difficulty tier instead of falling back to English words.

Fix UTF-8 accuracy in the game core
- update_game_state mixed byte and character counts: total_characters_typed
  accumulated byte-length deltas while total_correct_characters compared a
  char index against that byte count. Equal on ASCII, so it went unnoticed;
  a correctly typed Spanish passage scored 6%. The old byte slicing would
  also have panicked if an index landed inside a multi-byte character.
  Rewritten char-based, with regression tests.

Programming mode
- Replaced prose about programming with real code: 26 syntax-highlighted
  snippets across JavaScript, Python, Rust, C/Go/Java and shell. Single-line
  by necessity, since the typing input is a single-line field.

Layout and readability
- One icon rail arrangement on every screen: Settings/Store under the
  wordmark, Language/Theme/Friends/Account top-right, Stats/Leaderboard/
  Multiplayer bottom-right.
- Main menu: mode picker moved out of the Single Player button, which it was
  notching a divider through and pushing the label off-centre.
- Escape returns to the menu, closing any open popover first, and confirms
  before abandoning a live race.
- Split --text-color and --sub-color per theme; they shared one value that
  measured 3.65:1 against the background, below the 4.5:1 body-text floor.
- Semantic colours used in exactly one place each: gold for a personal best,
  amber for the race countdown and the mobile-result badge.
- Passage now sits in the same place on the typing and end screens, and its
  column is a whole number of characters wide so wrapping cannot leave a
  permanent gap on the right.
- End screen: keystrokes and a correct/wrong/extra/missed split, attribution
  carried over from the typing screen, and a graph with a separate error
  axis, axis titles including seconds, and smoothed lines.

1 files changed, 66 insertions, 0 deletions

diff --git a/web/src/stats.js b/web/src/stats.js
new file mode 100644
index 0000000..00d4db6
--- /dev/null
+++ b/web/src/stats.js
@@ -0,0 +1,66 @@
+export function emptyStats() {
+    return {
+        wpm: 0,
+        rawWpm: 0,
+        keystrokes: 0,
+        accuracy: 100,
+        time: 0,
+        correctChars: 0,
+        incorrectChars: 0,
+        totalChars: 0,
+        currentStreak: 0,
+        bestStreak: 0,
+    };
+}
+
+// `totalKeystrokes` is a persistent, never-decremented count of every forward
+// keystroke made during the test, including ones later backspaced away. It
+// must be tracked externally (see typingGame.js) because a backspaced
+// mistake is no longer present in `input` by the time this runs - without
+// it, raw WPM would silently collapse to equal WPM whenever the final input
+// happens to be fully correct, hiding every corrected mistake. Falls back to
+// `input.length` (final-state only) when the caller doesn't track it.
+export function calculateStats(input, text, elapsedTime, totalKeystrokes) {
+    let correct = 0;
+    let totalErrors = 0;
+    let currentStreak = 0;
+    let bestStreak = 0;
+    const hasStartedTyping = input.length > 0;
+
+    for (let i = 0; i < input.length; i++) {
+        if (i < text.length && input[i] === text[i]) {
+            correct++;
+            currentStreak++;
+            bestStreak = Math.max(bestStreak, currentStreak);
+        } else {
+            totalErrors++;
+            currentStreak = 0;
+        }
+    }
+
+    const totalTyped = input.length;
+    const accuracy = !hasStartedTyping ? 100 : Math.max(0, Math.min(100, (correct / totalTyped) * 100));
+    const wpm = elapsedTime === 0 ? 0 : (correct / 5) / (elapsedTime / 60);
+    // Raw WPM: same formula as WPM, but counting every keystroke ever made
+    // (right, wrong, or later corrected) instead of only correct ones --
+    // this is how MonkeyType/TypeRacer define it: raw speed ignores accuracy
+    // entirely, including keystrokes you fixed with backspace.
+    const rawCount = totalKeystrokes ?? totalTyped;
+    const rawWpm = elapsedTime === 0 ? 0 : (rawCount / 5) / (elapsedTime / 60);
+
+    return {
+        wpm,
+        rawWpm,
+        accuracy,
+        time: elapsedTime,
+        correctChars: correct,
+        incorrectChars: totalErrors,
+        totalChars: text.length,
+        // Every forward keystroke of the test, corrected-away ones included --
+        // the same figure rawWpm is derived from. Reported on the end screen
+        // in its own right, the way 10FastFingers does.
+        keystrokes: rawCount,
+        currentStreak,
+        bestStreak,
+    };
+}