Add --repo/--left/--right/--file CLI flags (closes #5)

DiffViewer is GUI-launch-only today. Add a named-flag command-line form
so terminals, shell aliases, and other tools can drive the app into a
specific (repo, left, right, [file]) context without going through the
launch-context picker.

Parser:
- CommandLineParser.Parse branches into a new flag-form path when the
  first positional arg begins with "--". The existing positional grammar
  (working-tree path, commit-vs-commit, two-commit, PR URL) is untouched.
- Required flags: --repo, --left, --right. Optional: --file.
- "WORKING" (case-insensitive) maps to DiffSide.WorkingTree; any other
  value is treated as a commit-ish and resolved through the existing
  RefResolver path.
- New CommandLineErrorKind values: MissingRequiredFlag, MissingFlagValue,
  UnexpectedPositionalArgument. Unknown flags fail loud (silent ignore
  would hide difftool-style misconfiguration).
- --file is normalized to Path.DirectorySeparatorChar with leading
  separators trimmed and stored on ParsedCommandLine.InitialFile.

File pre-selection:
- FileListViewModel.LoadFromChanges takes an optional preferredInitialPath
  and selects the matching entry by RepoRelativePath
  (OrdinalIgnoreCase) when there is no prior selection. Doing the
  selection inside LoadFromChanges keeps it within the IsReloading=true
  gate window, so the DiffPane reload still fires exactly once from the
  consolidated PropertyChanged at the end of the load.
- MainViewModel accepts an initialFile ctor param and threads it through.
- CompositionRoot passes parsed.InitialFile into the MainViewModel ctor.

Console / stderr:
- New Utility/ConsoleAttacher wraps AttachConsole(ATTACH_PARENT_PROCESS),
  idempotent, with cached IsAttached state. Best-effort: a double-click
  launch with no parent console just returns false.
- App.OnStartup calls AttachToParent() at the top, then wires a
  Console.Error.WriteLine-based stderrWriter into MainWindowCoordinator
  only when attachment succeeded.
- MainWindowCoordinator.HandleColdLaunchFailure invokes the writer
  (try/catch wrapped — best-effort) before the existing dialog and
  empty-state fallback paths. When launched from Explorer the dialog
  path is identical to before.

README + CHANGELOG:
- New "Command-line launch" section documenting the flag grammar plus a
  working `git` alias recipe (`git config --global alias.dv ...`).
- Honest note on why `git difftool` itself does not fit: it passes
  temp snapshot file paths as \/\, not commit-ish refs, so
  DiffViewer's flag form (which needs a real repo + refs to drive
  hunk staging, history, recents) cannot plug into difftool's slots.
- `[Unreleased]` "Added" entry covering the new flags and the error
  behavior.

Tests:
- CommandLineParserFlagFormTests: 26 tests covering required flags,
  WORKING sentinel (both sides, case-insensitive), --file
  normalization, mixed positional+flag rejection, unknown flag,
  unresolvable refs, missing repo, subdir discovery, ParseLaunch
  routing.
- FileListViewModelInitialPathTests: 7 tests for preferredInitialPath
  (match, case-insensitive, unmatched, null, empty, prior-selection-wins,
  commit-vs-commit layout).
- ConsoleAttacherTests: 2 tests for idempotency + IsAttached contract.
- MainWindowCoordinatorTests: 3 new tests for stderr writer
  (writes on parse failure, optional/null is still backward-compat,
  throwing writer does not derail dialog/shutdown).

Final state: dotnet build -c Release => 0 warnings, 0 errors.
dotnet test => 1199 passed, 1 skipped (unchanged live-network skip),
up from the 1161-passing baseline.

AI-Local-Session: d30f85c9-a0a8-47d4-8312-c1823ad4c3ec
AI-Cloud-Session: 8a8a3c25-8fc8-474f-8993-ac4289b7d964
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: geevensingh

CHANGELOG.md

@@ -14,6 +14,21 @@ body. Keep section headings exact and write notes in Markdown.
 
 ### Added
 
+- **Command-line flags for direct launch**: `DiffViewer.exe --repo
+  <path> --left <commit-ish | WORKING> --right <commit-ish | WORKING>
+  [--file <repo-relative-path>]` launches straight into a diff context,
+  bypassing the launch-context picker. `WORKING` is the sentinel for
+  "working tree" (matches `DiffSide.WorkingTree`). `--file` pre-selects
+  a file in the file list, with case-insensitive matching and both
+  forward- and backward-slash separators accepted. Errors (missing or
+  unknown flag, missing flag value, unresolvable ref, repo not found)
+  print to stderr and exit with status 1; when DiffViewer is launched
+  from a terminal those messages appear inline in that terminal, when
+  launched from Explorer they fall back to the existing error dialog.
+  The existing positional grammar (`DiffViewer.exe <path>`,
+  `DiffViewer.exe <pr-url>`, ...) is unchanged. See the new
+  "Command-line launch" section in the README for the `git` alias
+  recipe.
 - Hunk overview bar is now interactive for scrolling. Drag the
   viewport indicator (the soft blue outline that shows the editors'
   currently-visible window) up or down to scroll both editors —

DiffViewer.Tests/MainWindowCoordinatorTests.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Threading.Tasks;
 using DiffViewer;
 using DiffViewer.Models;
@@ -38,6 +40,74 @@ public async Task InitialLaunchAsync_ParseFailure_ShowsErrorAndShutsDown()
         coordinator.Current.Should().BeNull();
     }
 
+    [Fact]
+    public async Task InitialLaunchAsync_ParseFailure_AlsoWritesToStderr()
+    {
+        // The stderrWriter callback is wired in production from
+        // App.OnStartup when AttachConsole succeeds; the coordinator just
+        // forwards every cold-launch failure message through it so CLI
+        // consumers (git difftool) see the error in their terminal.
+        var dialog = new FakeDialog();
+        var services = BuildServices(out _);
+        var stderr = new List<string>();
+
+        var coordinator = new MainWindowCoordinator(
+            services, dialog, default,
+            shutdownAction: _ => { },
+            stderrWriter: stderr.Add);
+
+        await coordinator.InitialLaunchAsync(
+            new[] { "C:\\nope1", "C:\\nope2", "C:\\nope3" });
+
+        // Exact wording is the parser's; we just verify the structured
+        // failure made it through to the stderr callback verbatim.
+        stderr.Should().ContainSingle()
+            .Which.Should().Contain("C:\\nope1");
+    }
+
+    [Fact]
+    public async Task InitialLaunchAsync_ParseFailure_NoStderrWired_StillShowsDialog()
+    {
+        // Backward-compat: when no stderrWriter is supplied (GUI launch),
+        // the existing dialog-and-shutdown path must still fire identically.
+        var dialog = new FakeDialog();
+        int? exitCode = null;
+        var services = BuildServices(out _);
+
+        var coordinator = new MainWindowCoordinator(
+            services, dialog, default,
+            shutdownAction: c => exitCode = c,
+            stderrWriter: null);
+
+        var ok = await coordinator.InitialLaunchAsync(new[] { "--bogus" });
+
+        ok.Should().BeFalse();
+        dialog.LastError.Should().NotBeNull();
+        exitCode.Should().Be(1);
+    }
+
+    [Fact]
+    public async Task InitialLaunchAsync_StderrWriterThrows_DoesNotDerailFailureHandling()
+    {
+        // Best-effort contract: a misbehaving stderr writer (e.g. parent
+        // console closed between attach and write) must not prevent the
+        // dialog / shutdown from firing.
+        var dialog = new FakeDialog();
+        int? exitCode = null;
+        var services = BuildServices(out _);
+
+        var coordinator = new MainWindowCoordinator(
+            services, dialog, default,
+            shutdownAction: c => exitCode = c,
+            stderrWriter: _ => throw new IOException("simulated console gone"));
+
+        var ok = await coordinator.InitialLaunchAsync(new[] { "--bogus" });
+
+        ok.Should().BeFalse();
+        dialog.LastError.Should().NotBeNull();
+        exitCode.Should().Be(1);
+    }
+
     [Fact]
     public async Task StartFromParsedAsync_Success_SetsCurrentAndRecords()
     {