Freezes and crashes: the game's threads no longer wait on ReSkate's slow work

Players reported the game hanging for about a second while skating. A
profile showed the memory line in the log walking every heap
(HeapSummary) on the client thread, 0.5 to 2 s every two minutes. An
audit of everything that runs on the game's update and render threads
found more of the same, and Sentry's top crashes had causes of ours.

Freezes:
- Memory log line: no heap walk or thread snapshot; the GPU part and the
  write happen on a thread of their own.
- Profile database: synchronous=NORMAL in WAL mode. A save is still kept
  when the game crashes; every play event no longer waits for the disk
  inside the game's hooks.
- ReSkate's own preferences and values (menu clicks, session sliders,
  Discord) are saved by a background writer in order; reads see a value
  until it is saved.
- Input: the foreground window and the keyboard are sampled on a thread
  of their own (GetAncestor and GetAsyncKeyState stalled the client tick
  40-50 ms when another program held Windows' lock); flight input uses
  the sample; ClipCursor at most twice a second while a menu has the
  pointer.
- Hooks installed while the game runs go in one transaction per place
  (HookBatch): throwdowns, remote players, the party, Hall of Meat.
- Off the update thread: the host's map package lookup (one table read in
  the background, not the Mods folder per offer), the trainer's map file
  and settings save, Board Break's settings save, mod music playlists and
  their covers, the Spotify station covers.
- Off the render thread: the Modding page's and the deck card's Mods
  folder reads. The overlay's three startup waits share five seconds.
- Less work per frame: Steam names reused while one a frame is asked
  again, 2 friends a tick, steam_api64.dll checked once per process,
  cosmetic names read in place rather than a system call per character,
  an outfit load no longer copies the inventory per slot, the throwdown
  type scan runs at background priority over resident memory, the Board
  Break deck label is kept a minute.

Crashes:
- Render-resource pool: the metadata fields are written to the state
  owner only. The other renderer is 0x2daa00 bytes, and +0x11aae28 is far
  past its end (store_field crash; heap corruption in every release).
- Other players' skateboard effects: a stale skateboard component is no
  longer followed, and the joint lookup is walked with a bound first (an
  endless loop in reused memory ended in GameStall).
- Launcher: Oodle decodes into the buffer it asks for with corrupt data
  possible, and its assertions no longer stop the process (heap corruption
  in the store-copy scan; a breakpoint in oo2core).

Timings (Send performance timings):
- A frame of half a second or more in a level is sent as game.freeze:
  where the time went (ReSkate's tick, the game's frame, or outside it),
  whether the renderer kept presenting, and ReSkate's busiest zones.
- Closing the game sends the level session it was in.

Music after a connection drop:
- Spotify device: an account Spotify could not be reached with is kept and
  tried again (3 s doubling to a minute); a session that drops is taken
  up again. Only an account Spotify refuses is asked for anew.
- YouTube playlist pictures that could not be fetched are tried again,
  from 30 s to 10 minutes apart.

Extension/Throwdowns/throwdown_lab.cpp

@@ -1352,12 +1352,15 @@ void remember_player(std::uint32_t id) {
     }
 }
 // Type objects of the injected events; found on the heap and kept until the level is left.
-std::string ensure_types(std::initializer_list<std::uint32_t> hashes) {
+// `worker`: called on a thread of its own, which scans as the party focus's does (background
+// priority, only memory the game has in RAM). The full scan read every committed page and paged
+// the game's memory in while it skated, every few seconds while a type was missing (2026-10-15).
+std::string ensure_types(std::initializer_list<std::uint32_t> hashes, bool worker = false) {
     std::vector<NativeTypeQuery> queries;
     for (const auto hash : hashes) if (!type_of(hash)) queries.push_back({hash, 0});
     if (queries.empty()) return {};
     const auto world = lab().world.load(std::memory_order_acquire);
-    const auto missing = find_native_types(queries);
+    const auto missing = find_native_types(queries, worker);
     std::lock_guard lock(lab().mutex);
     if (lab().world.load(std::memory_order_acquire) != world) return "the level changed while the event types were looked for";
     for (const auto& q : queries) if (q.object) lab().types[q.hash] = q.object;
@@ -1958,7 +1961,7 @@ bool beacon_types_ready() {
         std::thread([] {
             auto& l = lab();
             try {
-                if (!ensure_types({event_beacon_move, event_beacon_despawn}).empty())
+                if (!ensure_types({event_beacon_move, event_beacon_despawn}, true).empty())
                     l.beacon_scan_retry.store(now_ms() + 10000, std::memory_order_release);
             } catch (...) { l.beacon_scan_retry.store(now_ms() + 10000, std::memory_order_release); }
             l.type_scan_running.store(false, std::memory_order_release);
@@ -1995,7 +1998,7 @@ bool prepare_throwdown_injection() noexcept {
                 const auto error = ensure_types({event_debug_spawn, event_add_ai, event_force_start, event_destroy,
                                                  event_remove_participant, event_player_score, event_request_turn_end,
                                                  event_skate_submit, event_force_destroy, event_criteria_attempt,
-                                                 event_slam_hit, event_leave_in_progress, event_onboarding_complete});
+                                                 event_slam_hit, event_leave_in_progress, event_onboarding_complete}, true);
                 if (!error.empty()) {
                     l.type_scan_retry.store(now_ms() + 5000, std::memory_order_release);
                     logging::log(logging::Level::warning, logging::Channel::progression, "Throwdowns: {}", error);