fn copy_key(&mut self, source: &OrdValStorage<L>, cursor: usize) {
            // Capture the initial number of values to determine if the merge was ultimately non-empty.
            let init_vals = self.result.vals.len();
            let (mut lower, upper) = source.values_for_key(cursor);
            while lower < upper {
                self.stash_updates_for_val(source, lower);
                if let Some(off) = self.consolidate_updates() {
                    self.result.vals_offs.push(off);
                    self.result.vals.push(source.vals.index(lower));
                }
                lower += 1;
            }            

            // If we have pushed any values, copy the key as well.
            if self.result.vals.len() > init_vals {
                self.result.keys.push(source.keys.index(cursor));
                self.result.keys_offs.push(self.result.vals.len());
            }           
        }
Copy the next key in `source`.

The method extracts the key in `source` at `cursor`, and merges it in to `self`.
If the result does not wholly cancel, they key will be present in `self` with the
compacted values and updates.

The caller should be certain to update the cursor, as this method does not do this.
differential-dataflow/src/trace/implementations/ord_neu.rs