Add ref picker and Branch-vs-merge-base mode to New Diff dialog

Issue #4: each commit-ish input in the New Diff dialog now has a
"Pick..." button that opens a popup listing the repo's local branches,
remote-tracking branches, tags, and recently-used refs (derived from
IRecentContextsService - no new persistence). A live filter narrows
every group; an inline merge-base composer covers ad-hoc "what did this
branch add" queries without leaving the dialog. Freeform typing still
works as a fallback.

Also adds a fifth top-level mode "Branch vs merge-base" so the dominant
PR-style review workflow gets one-click setup in the left rail (without
having to compose a merge-base by hand inside the picker). Resolves the
two refs against the repo, computes their merge-base, and launches with
merge-base on the left / branch tip on the right so additions land in
the right pane - same convention every other form follows.

Architecture:
- New IGitRefEnumerator service (stateless libgit2 probe, sibling of
  IRepoInspector). Production impl opens Repository per-call, returns
  Empty / null on throw, excludes synthetic origin/HEAD symlinks.
- New RefPickerViewModel - enumeration runs on Task.Run per AGENTS.md
  to keep the UI thread responsive; case-insensitive filter applied at
  render time; recent refs deduped + capped at 5 MRU-ordered.
- New RefPicker WPF UserControl - hosts a Popup (not a Window, so not a
  nested dialog) with IsOpen/PlacementTarget as DependencyProperties
  for clean XAML binding to a ToggleButton trigger.
- IDiffModeProvider.CreateForm now takes a FormDependencies record
  bundle (Validator, RefEnumerator, RecentContexts, PrefilledRepoPath)
  rather than positional args, so future form deps don't keep changing
  the signature.
- DiffModeRegistry.BuildDefault gains BranchVsMergeBaseProvider in 4th
  position (local family stays grouped, GitHub PR mode trails).

998 tests pass, 0 warnings.

AI-Local-Session: 324bab9a-4598-4558-bfa8-945af6bc48db
AI-Cloud-Session: 620cead1-bd37-4511-a627-8793b66717fd
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: geevensingh

CHANGELOG.md

@@ -14,6 +14,30 @@ body. Keep section headings exact and write notes in Markdown.
 
 ### Added
 
+- **New Diff dialog: ref picker for commit-ish inputs.** The
+  "Working tree vs commit" and "Commit vs commit" forms now have a
+  **Pick…** button next to each commit-ish field that opens a popup
+  listing the repo's local branches, remote-tracking branches, tags,
+  and refs you've recently used in this repo. A live case-insensitive
+  filter box narrows every group as you type; each row shows the
+  ref's friendly name plus its tip's short SHA. The popup also
+  includes an inline merge-base composer — fill two refs and click
+  **Compute & use** to substitute the resulting SHA into the field —
+  for ad-hoc "what did this branch add since it forked" comparisons
+  without leaving the dialog. Freeform typing still works as a
+  fallback. Enumeration happens off the UI thread so opening the
+  picker on a large repo doesn't freeze the dialog. Resolves
+  [#4](https://github.com/geevensingh/DiffViewer/issues/4).
+- **New Diff dialog: "Branch vs merge-base" mode.** A new top-level
+  mode in the left rail wires the dominant PR-style review workflow
+  ("what did this branch add since it forked from main") into a
+  one-click form. Takes a branch and a merge-base partner, resolves
+  their most recent common ancestor on submit, and launches a diff
+  with the merge-base on the left and the branch tip on the right —
+  so additions land in the right pane the same way every other form
+  produces. Surfaces "No common ancestor" inline when the two refs
+  have unrelated histories, rather than silently disabling **OK**.
+  Both commit-ish inputs get the same ref picker described above.
 - **File-list filter + per-file viewed checkbox.** A new bar above
   the display-mode toggle adds a case-insensitive substring filter
   (slash-insensitive: `foo/bar.cs` and `foo\bar.cs` both match) that

DiffViewer.Tests/Services/DiffModeRegistryTests.cs

@@ -7,18 +7,22 @@ namespace DiffViewer.Tests.Services;
 public class DiffModeRegistryTests
 {
     [Fact]
-    public void BuildDefault_ListsFourProvidersInExpectedOrder()
+    public void BuildDefault_ListsFiveProvidersInExpectedOrder()
     {
         // Order is part of the contract — it's what the dialog's
         // left-rail ListBox renders top-to-bottom. "Working tree vs
-        // HEAD" leads as the cheapest interaction.
+        // HEAD" leads as the cheapest interaction; the local
+        // comparison family stays grouped; "Branch vs merge-base"
+        // (the dominant PR-style workflow) lives alongside the
+        // local family above the cross-network GitHub-PR mode.
         var registry = DiffModeRegistry.BuildDefault();
 
-        registry.Providers.Should().HaveCount(4);
+        registry.Providers.Should().HaveCount(5);
         registry.Providers[0].Id.Should().Be(WorkingTreeVsHeadProvider.ProviderId);
         registry.Providers[1].Id.Should().Be(WorkingTreeVsCommitProvider.ProviderId);
         registry.Providers[2].Id.Should().Be(CommitVsCommitProvider.ProviderId);
-        registry.Providers[3].Id.Should().Be(GitHubPullRequestProvider.ProviderId);
+        registry.Providers[3].Id.Should().Be(BranchVsMergeBaseProvider.ProviderId);
+        registry.Providers[4].Id.Should().Be(GitHubPullRequestProvider.ProviderId);
     }
 
     [Fact]

DiffViewer.Tests/Services/GitRefEnumeratorTests.cs

@@ -0,0 +1,217 @@
+using DiffViewer.Services;
+using FluentAssertions;
+using LibGit2Sharp;
+using System.IO;
+using Xunit;
+
+namespace DiffViewer.Tests.Services;
+
+public class GitRefEnumeratorTests
+{
+    [Fact]
+    public void Enumerate_OnInvalidPath_ReturnsEmpty()
+    {
+        var bogus = Path.Combine(Path.GetTempPath(), "diffviewer-not-a-repo-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(bogus);
+        try
+        {
+            var sut = new LibGit2GitRefEnumerator();
+            var result = sut.Enumerate(bogus);
+
+            result.Should().BeSameAs(RefEnumerationResult.Empty);
+        }
+        finally
+        {
+            Directory.Delete(bogus, recursive: true);
+        }
+    }
+
+    [Fact]
+    public void Enumerate_OnEmptyOrNullPath_ReturnsEmpty()
+    {
+        var sut = new LibGit2GitRefEnumerator();
+        sut.Enumerate("").Should().BeSameAs(RefEnumerationResult.Empty);
+        sut.Enumerate("   ").Should().BeSameAs(RefEnumerationResult.Empty);
+    }
+
+    [Fact]
+    public void Enumerate_OnFreshRepoWithNoCommits_ReturnsEmptyLists()
+    {
+        using var t = new TempRepo();
+        var sut = new LibGit2GitRefEnumerator();
+
+        var result = sut.Enumerate(t.Path);
+
+        // Unborn HEAD: no branches resolve a Tip, no tags exist yet.
+        result.LocalBranches.Should().BeEmpty();
+        result.RemoteBranches.Should().BeEmpty();
+        result.Tags.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Enumerate_ReturnsLocalBranchesSortedAlphabetically()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        var c1 = t.InitialCommit("c1");
+        t.CreateBranch("feature/zebra", c1);
+        t.CreateBranch("feature/alpha", c1);
+
+        var sut = new LibGit2GitRefEnumerator();
+        var result = sut.Enumerate(t.Path);
+
+        result.LocalBranches.Select(b => b.FriendlyName)
+            .Should().ContainInOrder("feature/alpha", "feature/zebra")
+            .And.HaveCount(3); // alpha, zebra, and the default branch
+        result.LocalBranches.Should().AllSatisfy(b =>
+        {
+            b.TipSha.Should().Be(c1.Sha);
+            b.TipShortSha.Should().Be(c1.Sha[..7]);
+        });
+    }
+
+    [Fact]
+    public void Enumerate_SeparatesRemoteFromLocalBranches()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        var c1 = t.InitialCommit("c1");
+        t.CreateRemoteTrackingBranch("origin", "feature/x", c1);
+
+        var sut = new LibGit2GitRefEnumerator();
+        var result = sut.Enumerate(t.Path);
+
+        result.LocalBranches.Should().NotContain(b => b.FriendlyName.StartsWith("origin/"));
+        result.RemoteBranches.Select(b => b.FriendlyName)
+            .Should().Contain("origin/feature/x");
+    }
+
+    [Fact]
+    public void Enumerate_ExcludesOriginHeadFromRemoteBranches()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        var c1 = t.InitialCommit("c1");
+        t.CreateRemoteTrackingBranch("origin", "master", c1);
+
+        // Create the synthetic origin/HEAD symbolic ref pointing at
+        // origin/master — git fetch creates this automatically; we
+        // install it manually here.
+        using (var repo = new Repository(t.Path))
+        {
+            repo.Refs.Add("refs/remotes/origin/HEAD", "refs/remotes/origin/master", allowOverwrite: true);
+        }
+
+        var sut = new LibGit2GitRefEnumerator();
+        var result = sut.Enumerate(t.Path);
+
+        result.RemoteBranches.Should().NotContain(b => b.FriendlyName == "origin/HEAD");
+        result.RemoteBranches.Should().Contain(b => b.FriendlyName == "origin/master");
+    }
+
+    [Fact]
+    public void Enumerate_ReturnsLightweightAndAnnotatedTags()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        var c1 = t.InitialCommit("c1");
+        t.CreateLightweightTag("v0.1.0", c1);
+        t.CreateAnnotatedTag("v0.2.0", c1, "release 0.2");
+
+        var sut = new LibGit2GitRefEnumerator();
+        var result = sut.Enumerate(t.Path);
+
+        result.Tags.Select(x => x.FriendlyName)
+            .Should().Contain(new[] { "v0.1.0", "v0.2.0" });
+        result.Tags.Should().AllSatisfy(x =>
+        {
+            x.TipSha.Should().Be(c1.Sha);
+        });
+    }
+
+    [Fact]
+    public void TryComputeMergeBase_ReturnsCommonAncestor()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        var root = t.InitialCommit("root");
+
+        t.CreateBranch("branch-a", root);
+        t.Checkout("branch-a");
+        t.WriteFile("a.txt", "a-changed\n");
+        t.Commit("on branch-a");
+
+        // Default branch is still at root. Branch off another path
+        // from root so both sides have moved past it.
+        t.CreateBranch("branch-b", root);
+        t.Checkout("branch-b");
+        t.WriteFile("b.txt", "b\n");
+        t.Commit("on branch-b");
+
+        var sut = new LibGit2GitRefEnumerator();
+        var mb = sut.TryComputeMergeBase(t.Path, "branch-a", "branch-b");
+
+        mb.Should().Be(root.Sha);
+    }
+
+    [Fact]
+    public void TryComputeMergeBase_OnUnrelatedHistories_ReturnsNull()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        var c1 = t.InitialCommit("c1");
+
+        // Build a parentless commit via the libgit2 ObjectDatabase
+        // primitives and tag it. That commit shares no ancestor with
+        // c1, so the merge-base must come back null.
+        using (var repo = new Repository(t.Path))
+        {
+            var tree = repo.Lookup<Commit>(c1.Sha)!.Tree;
+            var orphan = repo.ObjectDatabase.CreateCommit(
+                t.Author, t.Author, "orphan", tree,
+                parents: Array.Empty<Commit>(),
+                prettifyMessage: true);
+            repo.Refs.Add("refs/heads/orphan", orphan.Sha);
+        }
+
+        var sut = new LibGit2GitRefEnumerator();
+        var mb = sut.TryComputeMergeBase(t.Path, c1.Sha, "orphan");
+
+        mb.Should().BeNull();
+    }
+
+    [Fact]
+    public void TryComputeMergeBase_OnUnresolvableRef_ReturnsNull()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        t.InitialCommit("c1");
+
+        var sut = new LibGit2GitRefEnumerator();
+
+        sut.TryComputeMergeBase(t.Path, "master", "does-not-exist").Should().BeNull();
+        sut.TryComputeMergeBase(t.Path, "does-not-exist", "master").Should().BeNull();
+    }
+
+    [Fact]
+    public void TryComputeMergeBase_OnInvalidPath_ReturnsNull()
+    {
+        var sut = new LibGit2GitRefEnumerator();
+
+        sut.TryComputeMergeBase("", "a", "b").Should().BeNull();
+        sut.TryComputeMergeBase(@"C:\nope-" + Guid.NewGuid().ToString("N"), "a", "b").Should().BeNull();
+    }
+
+    [Fact]
+    public void TryComputeMergeBase_OnEmptyRefArgs_ReturnsNull()
+    {
+        using var t = new TempRepo();
+        t.WriteFile("a.txt", "a\n");
+        t.InitialCommit("c1");
+
+        var sut = new LibGit2GitRefEnumerator();
+
+        sut.TryComputeMergeBase(t.Path, "", "master").Should().BeNull();
+        sut.TryComputeMergeBase(t.Path, "master", "  ").Should().BeNull();
+    }
+}