Persist: clarify reduced semantics to refer only to spine structure

The exert function is called exclusively by the catalog force compaction
code path. In the case that there was only one spine batch with multiple
hollow batches, the exert function would incorrectly introduce empty
SpineBatches. The behavior of the `reduced` function was always using
the number of HollowBatches as a proxy for the structural shape of the
spine. With incremental compaction, there might be only one run with
a number of empty HollowBatches. This is totally legal, and not a reason
to try and force structural merges.

Author: DAlperin

src/persist-client/src/internal/trace.rs

@@ -1744,15 +1744,21 @@ impl<T: Timestamp + Lattice> Spine<T> {
         self.introduce_batch(batch, usize::cast_from(index.trailing_zeros()), log);
     }
 
-    /// True iff there is at most one HollowBatch in `self.merging`.
+    /// Returns true when the trace is considered *structurally reduced*.
     ///
-    /// When true, there is no maintenance work to perform in the trace, other
-    /// than compaction. We do not yet have logic in place to determine if
-    /// compaction would improve a trace, so for now we are ignoring that.
+    /// Reduced == the total number of runs (across every
+    /// `SpineBatch` and all of their inner hollow batches) is < 2. In other
+    /// words, there are either zero runs (fully empty) or exactly one logical
+    /// run of data remaining.
     fn reduced(&self) -> bool {
         self.spine_batches()
-            .flat_map(|b| b.parts.as_slice())
-            .count()
+            .map(|b| {
+                b.parts
+                    .iter()
+                    .map(|p| p.batch.run_meta.len())
+                    .sum::<usize>()
+            })
+            .sum::<usize>()
             < 2
     }