Move git status out of Entry (#22224)

- [x] Rewrite worktree git handling
- [x] Fix tests
- [x] Fix `test_propagate_statuses_for_repos_under_project`
- [x] Replace `WorkDirectoryEntry` with `WorkDirectory` in
`RepositoryEntry`
- [x] Add a worktree event for capturing git status changes
- [x] Confirm that the local repositories are correctly updating the new
WorkDirectory field
- [x] Implement the git statuses query as a join when pulling entries
out of worktree
- [x] Use this new join to implement the project panel and outline
panel.
- [x] Synchronize git statuses over the wire for collab and remote dev
(use the existing `worktree_repository_statuses` table, adjust as
needed)
- [x] Only send changed statuses to collab

Release Notes:

- N/A

---------

Co-authored-by: Cole Miller <cole@zed.dev>
Co-authored-by: Mikayla <mikayla@zed.com>
Co-authored-by: Nathan <nathan@zed.dev>

crates/sum_tree/src/cursor.rs

@@ -9,6 +9,15 @@ struct StackEntry<'a, T: Item, D> {
     position: D,
 }
 
+impl<'a, T: Item + fmt::Debug, D: fmt::Debug> fmt::Debug for StackEntry<'a, T, D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StackEntry")
+            .field("index", &self.index)
+            .field("position", &self.position)
+            .finish()
+    }
+}
+
 #[derive(Clone)]
 pub struct Cursor<'a, T: Item, D> {
     tree: &'a SumTree<T>,
@@ -18,6 +27,21 @@ pub struct Cursor<'a, T: Item, D> {
     at_end: bool,
 }
 
+impl<'a, T: Item + fmt::Debug, D: fmt::Debug> fmt::Debug for Cursor<'a, T, D>
+where
+    T::Summary: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Cursor")
+            .field("tree", &self.tree)
+            .field("stack", &self.stack)
+            .field("position", &self.position)
+            .field("did_seek", &self.did_seek)
+            .field("at_end", &self.at_end)
+            .finish()
+    }
+}
+
 pub struct Iter<'a, T: Item> {
     tree: &'a SumTree<T>,
     stack: ArrayVec<StackEntry<'a, T, ()>, 16>,
@@ -60,6 +84,7 @@ where
         }
     }
 
+    /// Item is None, when the list is empty, or this cursor is at the end of the list.
     #[track_caller]
     pub fn item(&self) -> Option<&'a T> {
         self.assert_did_seek();

crates/sum_tree/src/sum_tree.rs

@@ -42,6 +42,21 @@ pub trait Summary: Clone {
     fn add_summary(&mut self, summary: &Self, cx: &Self::Context);
 }
 
+/// This type exists because we can't implement Summary for () without causing
+/// type resolution errors
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Unit;
+
+impl Summary for Unit {
+    type Context = ();
+
+    fn zero(_: &()) -> Self {
+        Unit
+    }
+
+    fn add_summary(&mut self, _: &Self, _: &()) {}
+}
+
 /// Each [`Summary`] type can have more than one [`Dimension`] type that it measures.
 ///
 /// You can use dimensions to seek to a specific location in the [`SumTree`]
@@ -761,6 +776,55 @@ impl<T: KeyedItem> SumTree<T> {
             None
         }
     }
+
+    #[inline]
+    pub fn contains(&self, key: &T::Key, cx: &<T::Summary as Summary>::Context) -> bool {
+        self.get(key, cx).is_some()
+    }
+
+    pub fn update<F, R>(
+        &mut self,
+        key: &T::Key,
+        cx: &<T::Summary as Summary>::Context,
+        f: F,
+    ) -> Option<R>
+    where
+        F: FnOnce(&mut T) -> R,
+    {
+        let mut cursor = self.cursor::<T::Key>(cx);
+        let mut new_tree = cursor.slice(key, Bias::Left, cx);
+        let mut result = None;
+        if Ord::cmp(key, &cursor.end(cx)) == Ordering::Equal {
+            let mut updated = cursor.item().unwrap().clone();
+            result = Some(f(&mut updated));
+            new_tree.push(updated, cx);
+            cursor.next(cx);
+        }
+        new_tree.append(cursor.suffix(cx), cx);
+        drop(cursor);
+        *self = new_tree;
+        result
+    }
+
+    pub fn retain<F: FnMut(&T) -> bool>(
+        &mut self,
+        cx: &<T::Summary as Summary>::Context,
+        mut predicate: F,
+    ) {
+        let mut new_map = SumTree::new(cx);
+
+        let mut cursor = self.cursor::<T::Key>(cx);
+        cursor.next(cx);
+        while let Some(item) = cursor.item() {
+            if predicate(&item) {
+                new_map.push(item.clone(), cx);
+            }
+            cursor.next(cx);
+        }
+        drop(cursor);
+
+        *self = new_map;
+    }
 }
 
 impl<T, S> Default for SumTree<T>