index: omit operations that should be covered by the parent index

I'm not going to add operation index anytime soon, but this might help if we
decide to. Suppose we index "commit_id: originating_op_id" relations, we'll
probably want to store op_id in a separate sstable to save disk space. If the
table contains all operation ids, we can reuse it to resolve short operation
ids.

lib/src/default_index/store.rs

···
 #![allow(missing_docs)]
 
 use std::any::Any;
+use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fs;
 use std::io;
···
         let change_id_length = store.change_id_length();
         let mut visited_heads: HashSet<CommitId> = HashSet::new();
         let mut historical_heads: Vec<(CommitId, OperationId)> = Vec::new();
-        let mut parent_op_id: Option<OperationId> = None;
-        for op in op_walk::walk_ancestors(slice::from_ref(operation)) {
-            let op = op?;
-            // Pick the latest existing ancestor operation as the parent
-            // segment.
-            if parent_op_id.is_none() && operations_dir.join(op.id().hex()).is_file() {
-                parent_op_id = Some(op.id().clone());
+        let ops_to_visit: Vec<_> =
+            op_walk::walk_ancestors(slice::from_ref(operation)).try_collect()?;
+        // Pick the latest existing ancestor operation as the parent segment.
+        let parent_op = ops_to_visit
+            .iter()
+            .find(|op| operations_dir.join(op.id().hex()).is_file())
+            .cloned();
+        // Remove ancestors of the latest existing operation, which should have
+        // been indexed in the parent segment. This could be optimized for
+        // linear history, but parent_op is often None.
+        let ops_to_visit = if let Some(op) = &parent_op {
+            let mut wanted_ops: HashMap<&OperationId, &Operation> =
+                ops_to_visit.iter().map(|op| (op.id(), op)).collect();
+            let mut work = vec![op.id()];
+            while let Some(id) = work.pop() {
+                if let Some(op) = wanted_ops.remove(id) {
+                    work.extend(op.parent_ids());
+                }
             }
-            // TODO: no need to walk ancestors of the parent_op_id operation
+            ops_to_visit
+                .iter()
+                .filter(|op| wanted_ops.contains_key(op.id()))
+                .cloned()
+                .collect()
+        } else {
+            ops_to_visit
+        };
+        tracing::info!(
+            ops_count = ops_to_visit.len(),
+            "collecting head commits to index"
+        );
+        for op in &ops_to_visit {
             for commit_id in op.view()?.all_referenced_commit_ids() {
                 if visited_heads.insert(commit_id.clone()) {
                     historical_heads.push((commit_id.clone(), op.id().clone()));
···
         }
         let maybe_parent_file;
         let mut mutable_index;
-        match parent_op_id {
+        match &parent_op {
             None => {
                 maybe_parent_file = None;
                 mutable_index = DefaultMutableIndex::full(commit_id_length, change_id_length);
             }
-            Some(parent_op_id) => {
+            Some(op) => {
                 let parent_file = self.load_index_segments_at_operation(
-                    &parent_op_id,
+                    op.id(),
                     commit_id_length,
                     change_id_length,
                 )?;