fix(repo): return actual historical paths from incremental blame

<!-- agent -->
`Repo.blame_incremental()` copied Git's `filename` field into
`BlameEntry.orig_path` without interpreting its C-style quoting. After
renaming `café.txt` to `current.txt`, callers received
`"caf\303\251.txt"` instead of `café.txt`, so following an attribution
back to its original tree entry failed. Quotes, backslashes and control
characters had the same problem, even with `core.quotePath=false`.

Decode quoted filenames with the existing `git.diff._unquote_path()`
helper before constructing each entry. This shared point handles both
newly encountered and cached commits, leaves unquoted names unchanged,
and retains `safe_decode()`'s byte-preserving `surrogateescape` behavior.
`Repo.blame(..., incremental=True)` receives the same correction. Blame
continues to use Git's CLI on both backends; this is an output-parser fix,
not a new Gix implementation.

Add an independently written tree-based fixture and regression covering
eight historical filenames with both `core.quotePath` settings. Renaming
then editing the middle line produces two separated entries attributed
to the same original commit, exercising both parser branches. Check the
commit, original path and both line ranges through both public entry
points. Tree construction avoids platform restrictions on checking out
control-character and invalid-UTF-8 filenames.

The regression failed in ten quoted-filename subcases on each backend
before the fix and passes afterward. Repository and diff tests pass on
both backends; Ruff lint/format, mypy and ShellCheck also pass.

Git evidence: the comparison binary is `git version 2.54.0 (Apple
Git-157)`. Reference checkout revision
`6de20f6092dcf9bdb1c8efe03db4b70c82b423dd` documents the terminating
`filename` field in `Documentation/git-blame.adoc`; its
`builtin/blame.c:write_filename_info()` uses `write_name_quoted()`.
The regression's real `git blame --incremental HEAD -- current.txt`
output quotes the historical path in both entries for the original
commit, matching that format.

Independent solution to the problem reported and investigated by
`Keerthana-64` in #2314.
No implementation or tests were taken from that PR.

Assisted-by: GPT 6.1 Sol
Co-authored-by: GPT 6.1 Sol <codex@openai.com>

Author: Byron

git/repo/base.py

@@ -1293,6 +1293,8 @@ def blame_incremental(
         If you combine all line number ranges outputted by this command, you should get
         a continuous range spanning all line numbers in the file.
         """
+        from git.diff import _unquote_path
+
         if not allow_unsafe_options:
             Git.check_unsafe_options(
                 options=Git._option_candidates([rev], kwargs),
@@ -1375,6 +1377,9 @@ def blame_incremental(
                         orig_filename = value
                         break
 
+            if orig_filename.startswith(b'"') and orig_filename.endswith(b'"'):
+                orig_filename = _unquote_path(orig_filename[1:-1])
+
             yield BlameEntry(
                 commits[hexsha],
                 range(lineno, lineno + num_lines),

test/test_repo.py

@@ -36,6 +36,7 @@
     Submodule,
     Tree,
 )
+from git.compat import safe_decode
 from git.exc import BadObject, UnsafeOptionError, UnsafeProtocolError
 from git.repo.fun import find_worktree_git_dir
 from git.util import bin_to_hex, cwd, rmfile, rmtree
@@ -754,6 +755,34 @@ def test_blame_incremental(self, git):
                 ),
             )
 
+    def test_blame_incremental_preserves_historical_paths(self):
+        paths = (
+            b"plain.txt",
+            b" spaced name.txt ",
+            "café.txt".encode(),
+            b"byte-\xff.txt",
+            b'"literal-\\303\\251.txt"',
+            b'quote"name.txt',
+            b"back\\slash.txt",
+            b"control\a\b\t\n\v\f\r.txt",
+        )
+        for quote_path in ("true", "false"):
+            for i, path in enumerate(paths):
+                with self.subTest(quote_path=quote_path, path=path), fixture_repo(
+                    "blame-paths.sh", quote_path, subdir=str(i)
+                ) as repo:
+                    entries = list(repo.blame_incremental("HEAD", "current.txt"))
+                    original = repo.commit("HEAD~2")
+                    self.assertEqual(
+                        sorted(entries, key=lambda e: e.linenos.start),
+                        [
+                            (original, range(1, 2), safe_decode(path), range(1, 2)),
+                            (repo.head.commit, range(2, 3), "current.txt", range(2, 3)),
+                            (original, range(3, 4), safe_decode(path), range(3, 4)),
+                        ],
+                    )
+                    self.assertEqual(list(repo.blame("HEAD", "current.txt", incremental=True)), entries)
+
     @mock.patch.object(Git, "_call_process")
     def test_blame_complex_revision(self, git):
         git.return_value = fixture("blame_complex_revision")

tests/fixtures/blame-paths.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -eu
+# Tree entries allow historical names that cannot be checked out on every platform.
+paths=('plain.txt' ' spaced name.txt ' $'caf\303\251.txt' $'byte-\377.txt' '"literal-\303\251.txt"' 'quote"name.txt' 'back\slash.txt' $'control\a\b\t\n\v\f\r.txt')
+for i in "${!paths[@]}"; do
+    git init -q --initial-branch=main "$i"
+    (
+        cd "$i"
+        git config core.quotePath "$1"
+        blob=$(printf 'first\nmiddle\nlast\n' | git hash-object -w --stdin)
+        tree=$(printf '100644 blob %s\t%s\0' "$blob" "${paths[$i]}" | git mktree -z)
+        original=$(git commit-tree "$tree" -m original)
+        tree=$(printf '100644 blob %s\tcurrent.txt\0' "$blob" | git mktree -z)
+        renamed=$(git commit-tree "$tree" -p "$original" -m rename)
+        blob=$(printf 'first\nchanged\nlast\n' | git hash-object -w --stdin)
+        tree=$(printf '100644 blob %s\tcurrent.txt\0' "$blob" | git mktree -z)
+        edited=$(git commit-tree "$tree" -p "$renamed" -m edit)
+        git update-ref refs/heads/main "$edited"
+    )
+done