copies: inline `adjust_for_copy_tracking()`

We now have only one caller, and it's in a different module, so it
makes more sense to move it there.

lib/src/copies.rs

···
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         self.inner.as_mut().poll_next(cx).map(|option| {
             option.map(|diff_entry| {
-                diff_entry.adjust_for_copy_tracking(&self.source_tree, self.copy_records)
+                let Some(CopyRecord { source, .. }) =
+                    self.copy_records.for_target(&diff_entry.target)
+                else {
+                    return diff_entry;
+                };
+
+                TreeDiffEntry {
+                    source: source.clone(),
+                    target: diff_entry.target,
+                    value: diff_entry.value.and_then(|(_, target_value)| {
+                        self.source_tree
+                            .path_value(source)
+                            .map(|source_value| (source_value, target_value))
+                    }),
+                }
             })
         })
     }

lib/src/merged_tree.rs

···
 use itertools::{EitherOrBoth, Itertools};
 
 use crate::backend;
-use crate::backend::{BackendResult, CopyRecord, MergedTreeId, TreeId, TreeValue};
+use crate::backend::{BackendResult, MergedTreeId, TreeId, TreeValue};
 use crate::copies::{CopiesTreeDiffStream, CopyRecords};
 use crate::matchers::{EverythingMatcher, Matcher};
 use crate::merge::{Merge, MergeBuilder, MergedTreeVal, MergedTreeValue};
···
     pub target: RepoPathBuf,
     /// The resolved tree values if available.
     pub value: BackendResult<(MergedTreeValue, MergedTreeValue)>,
-}
-
-impl TreeDiffEntry {
-    pub(crate) fn adjust_for_copy_tracking(
-        self,
-        source_tree: &MergedTree,
-        copy_records: &CopyRecords,
-    ) -> TreeDiffEntry {
-        let Some(CopyRecord { source, .. }) = copy_records.for_target(&self.target) else {
-            return self;
-        };
-
-        Self {
-            source: source.clone(),
-            target: self.target,
-            value: self.value.and_then(|(_, target_value)| {
-                source_tree
-                    .path_value(source)
-                    .map(|source_value| (source_value, target_value))
-            }),
-        }
-    }
 }
 
 /// Type alias for the result from `MergedTree::diff_stream()`. We use a