fn insert_key(&mut self, key: <L::KeyContainer as BatchContainer>::ReadItem<'_>, offset: Option<usize>) {
            let desired = self.desired_location(&key);
            // Were we to push the key now, it would be at `self.keys.len()`, so while that is wrong, 
            // push additional blank entries in.
            while self.keys.len() < desired {
                // We insert a default (dummy) key and repeat the offset to indicate this.
                let current_offset = self.keys_offs.index(self.keys.len());
                self.keys.push(<<L::Target as Update>::Key as Default>::default());
                self.keys_offs.push(current_offset);
            }

            // Now we insert the key. Even if it is no longer the desired location because of contention.
            // If an offset has been supplied we insert it, and otherwise leave it for future determination.
            self.keys.push(key);
            if let Some(offset) = offset {
                self.keys_offs.push(offset);
            }
            self.key_count += 1;
        }
Inserts the key at its desired location, or nearby.

Because there may be collisions, they key may be placed just after its desired location.
If necessary, this method will introduce default keys and copy the offsets to create space
after which to insert the key. These will be indicated by `None` entries in the `hash` vector.

If `offset` is specified, we will insert it at the appropriate location. If it is not specified,
we leave `keys_offs` ready to receive it as the next `push`. This is so that builders that may
not know the final offset at the moment of key insertion can prepare for receiving the offset.
differential-dataflow/src/trace/implementations/rhh.rs