Add failing gix blob-merge tests for Myers algorithm issue

gix's blob merge (gix_merge::blob::builtin_driver::text) with the Myers
diff algorithm produces a false conflict on inputs where git merge-file
resolves cleanly. The trigger is a 3-way merge where base→ours is a
large expansion (~70 new lines inserted above a section comment) and
base→theirs is a single-line deletion of that same comment. imara-diff's
Myers implementation produces different hunk boundaries than git's xdiff
for this input, causing the merge to see the deletion as overlapping
with the insertion — a false conflict. The Histogram algorithm in
imara-diff handles the same input correctly.

This directly impacts GitButler's commit amend operation: create_tree()
uses gix's tree merge for the cherry-pick step, and the false conflict
causes valid changes to be rejected with CherryPickMergeConflict.

Add a #[should_panic] test that documents the upstream bug and will
start failing (reminding us to remove the annotation) once gix is fixed,
plus a Histogram-based test that verifies the working alternative.

Upstream: GitoxideLabs/gitoxide#2475

Author: mtsgrd

crates/but-core/tests/core/main.rs

@@ -3,6 +3,7 @@ mod change_id;
 mod cmd;
 mod commit;
 mod diff;
+mod merge;
 mod extract_remote_name_and_short_name;
 mod json_samples;
 mod ref_metadata;

crates/but-core/tests/core/merge.rs

@@ -0,0 +1,111 @@
+/// Tests for gix blob-merge behaviour.
+///
+/// Some tests in this module are expected to **fail** until an upstream gix bug
+/// is resolved.  Those tests are marked `#[should_panic]` so the test suite
+/// stays green in the interim; once gix is fixed the annotation must be removed.
+use gix::merge::blob::{
+    builtin_driver::text::{Conflict, ConflictStyle, Labels, Options},
+    Resolution,
+};
+
+fn fixtures() -> std::path::PathBuf {
+    let dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests/fixtures/merge");
+    assert!(dir.exists(), "fixtures directory missing: {dir:?}");
+    dir
+}
+
+/// gix's Myers blob merge produces a false conflict on certain inputs where
+/// `git merge-file` (also Myers-based) resolves cleanly.
+///
+/// Scenario
+/// --------
+/// * **base** (71 lines)  – original version of a Svelte component
+/// * **ours** (164 lines) – heavily expanded version: ~70 new lines inserted
+///   above a section comment, everything below the comment unchanged
+/// * **theirs** (70 lines) – identical to base except the section comment is
+///   deleted (single-line deletion)
+///
+/// git resolves this cleanly: keep the new block from ours, apply the comment
+/// deletion from theirs.  `git merge-file -p ours base theirs` exits 0.
+/// imara-diff's Myers implementation produces different hunk boundaries for the
+/// large base→ours expansion, which makes the 3-way merge see the small
+/// theirs deletion as overlapping with ours' insertion — a false conflict.
+///
+/// Upstream issue: https://github.com/GitoxideLabs/gitoxide/issues/2475
+///
+/// Remove `#[should_panic]` once the upstream fix lands.
+#[test]
+#[should_panic(
+    expected = "gix Myers blob merge should resolve cleanly (upstream bug: \
+                https://github.com/GitoxideLabs/gitoxide/issues/2475)"
+)]
+fn myers_blob_merge_false_conflict_with_large_insertion_and_adjacent_deletion() {
+    let dir = fixtures();
+    let base = std::fs::read(dir.join("base.svelte")).unwrap();
+    let ours = std::fs::read(dir.join("ours.svelte")).unwrap();
+    let theirs = std::fs::read(dir.join("theirs.svelte")).unwrap();
+
+    let labels = Labels {
+        ancestor: Some("base".into()),
+        current: Some("ours".into()),
+        other: Some("theirs".into()),
+    };
+    let options = Options {
+        diff_algorithm: gix::diff::blob::Algorithm::Myers,
+        conflict: Conflict::Keep {
+            style: ConflictStyle::Merge,
+            marker_size: std::num::NonZeroU8::new(7).unwrap(),
+        },
+    };
+
+    let mut out = Vec::new();
+    let mut input = gix::diff::blob::intern::InternedInput::new(&[][..], &[][..]);
+    let resolution =
+        gix::merge::blob::builtin_driver::text(&mut out, &mut input, labels, &ours, &base, &theirs, options);
+
+    assert_eq!(
+        resolution,
+        Resolution::Complete,
+        "gix Myers blob merge should resolve cleanly (upstream bug: \
+         https://github.com/GitoxideLabs/gitoxide/issues/2475)"
+    );
+}
+
+/// Sanity check: the Histogram algorithm already resolves the same input
+/// without conflicts.  This test must always pass.
+#[test]
+fn histogram_blob_merge_resolves_large_insertion_and_adjacent_deletion() {
+    let dir = fixtures();
+    let base = std::fs::read(dir.join("base.svelte")).unwrap();
+    let ours = std::fs::read(dir.join("ours.svelte")).unwrap();
+    let theirs = std::fs::read(dir.join("theirs.svelte")).unwrap();
+
+    let labels = Labels {
+        ancestor: Some("base".into()),
+        current: Some("ours".into()),
+        other: Some("theirs".into()),
+    };
+    let options = Options {
+        diff_algorithm: gix::diff::blob::Algorithm::Histogram,
+        conflict: Conflict::Keep {
+            style: ConflictStyle::Merge,
+            marker_size: std::num::NonZeroU8::new(7).unwrap(),
+        },
+    };
+
+    let mut out = Vec::new();
+    let mut input = gix::diff::blob::intern::InternedInput::new(&[][..], &[][..]);
+    let resolution =
+        gix::merge::blob::builtin_driver::text(&mut out, &mut input, labels, &ours, &base, &theirs, options);
+
+    assert_eq!(
+        resolution,
+        Resolution::Complete,
+        "Histogram should merge without conflicts"
+    );
+    assert!(
+        !String::from_utf8_lossy(&out).contains("<<<<<<<"),
+        "Histogram merge output should contain no conflict markers"
+    );
+}