refactor(main): fold remaining main-deps builders into their handlers (#308)

* refactor(main): drop remaining pass-through main-deps builders

Jellyfin client-info/setup-window/remote, overlay shortcuts/visibility/
layout/window-factory, config hot-reload, and startup bootstrap factory
builders only forwarded deps. Callers now pass deps to the handlers
directly; createWatchConfigPathHandler moves into config-hot-reload-handlers.

* refactor(main): fold small-logic main-deps builders into their handlers

Tray click, mpv client factory, startup bootstrap exit callbacks, overlay
runtime options, and dictionary roots/runtime builders move their logic
into the owning handler or call site. The two duplicated dictionary-root
builders become one createBuildDictionaryRootsHandler(vendorDirName).

* refactor(main): fold cli command context builders into the factory

createCliCommandContextFactory now adapts appState and main services to
the CLI command context deps directly (socket-path change notification,
texthooker port/websocket URL, browser-open default). The pass-through
cli-command-context-main-deps and cli-command-context-deps layers are
removed; their behavioural tests now run against the factory's context.

* refactor(main): fold subtitle tokenization builder into the mpv composer

The tokenizer deps builder's logic (known-word lookup recording and the
character-dictionary gate on name matching) becomes
buildTokenizerRuntimeOptions in mpv-runtime-composer, tested through the
composer. The MeCab check and dictionary prewarm handlers move to
subtitle-tokenization-warmup.ts, and the unused BuiltMainDeps type is
removed from composer contracts.

* refactor(main): drop redundant tokenizer deps keys and cast

* refactor(main): end the main-deps builder pattern

mpv-main-event-main-deps becomes mpv-main-event-binding-deps
(createMpvMainEventBindingDeps), returning the binding deps directly
instead of a thunk; it owns the subtitle-recording state. The will-quit
cleanup adapter likewise returns its deps directly, and the pass-through
app-lifecycle activate builders are removed.

* docs: drop references to main-deps builders

src/main/runtime/startup-runtime-handlers.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { StartupBootstrapRuntimeFactoryDeps } from '../startup';
+import { createStartupRuntimeHandlers } from './startup-runtime-handlers';
+
+function buildBootstrapDeps() {
+  const state = { exitCodes: [] as number[], quitCount: 0, errors: [] as string[] };
+  const captured: StartupBootstrapRuntimeFactoryDeps[] = [];
+  const { runAndApplyStartupState } = createStartupRuntimeHandlers({
+    appLifecycleRuntimeRunnerMainDeps: {} as never,
+    createAppLifecycleRuntimeRunner: () => () => {},
+    buildStartupBootstrapMainDeps: (startAppLifecycle) => ({
+      argv: ['node', 'main.js'],
+      parseArgs: () => ({}) as never,
+      setLogLevel: () => {},
+      forceX11Backend: () => {},
+      enforceUnsupportedWaylandMode: () => {},
+      shouldStartApp: () => true,
+      getDefaultSocketPath: () => '/tmp/mpv.sock',
+      defaultTexthookerPort: 5174,
+      configDir: '/tmp/config',
+      defaultConfig: {} as never,
+      generateConfigTemplate: () => 'template',
+      generateDefaultConfigFile: async () => 0,
+      setExitCode: (code) => state.exitCodes.push(code),
+      quitApp: () => {
+        state.quitCount += 1;
+      },
+      logGenerateConfigError: (message) => state.errors.push(message),
+      startAppLifecycle,
+    }),
+    createStartupBootstrapRuntimeDeps: (deps) => deps,
+    runStartupBootstrapRuntime: (deps) => {
+      captured.push(deps);
+    },
+    applyStartupState: () => {},
+  });
+  runAndApplyStartupState();
+  const [deps] = captured;
+  assert.ok(deps);
+  return { deps, state };
+}
+
+test('onConfigGenerated exits with the generator exit code', () => {
+  const { deps, state } = buildBootstrapDeps();
+  deps.onConfigGenerated(7);
+  assert.deepEqual(state.exitCodes, [7]);
+  assert.equal(state.quitCount, 1);
+  assert.deepEqual(state.errors, []);
+});
+
+test('onGenerateConfigError logs the failure and exits with code 1', () => {
+  const { deps, state } = buildBootstrapDeps();
+  deps.onGenerateConfigError(new Error('boom'));
+  assert.deepEqual(state.errors, ['Failed to generate config: boom']);
+  assert.deepEqual(state.exitCodes, [1]);
+  assert.equal(state.quitCount, 1);
+});