Function group_consecutive

crates/kernel/src/canonical_check.rs:598–622

Group consecutive equal elements in a sorted slice. Mirrors `group_by` (`src/ix/compile.rs:2644`) — the consecutive-equal grouping is sound because the input is already sorted by the same comparator.

(
  items: Vec<(KId<M>, &'a KConst<M>)>,
  ctx: &KMutCtx,
  resolve_ctor: &dyn Fn(&KId<M>) -> Option<KConst<M>>,
)

  let mut groups: Vec<Vec<(KId<M>, &'a KConst<M>)>> = Vec::new();
  let mut current: Vec<(KId<M>, &'a KConst<M>)> = Vec::new();
  for item in items {
    if let Some(last) = current.last() {
      let eq = compare_kconst(last.1, item.1, ctx, resolve_ctor)?.ordering
        == Ordering::Equal;
      if eq {
        current.push(item);
      } else {
        groups.push(std::mem::replace(&mut current, vec![item]));
      }
    } else {
      current.push(item);
    }
  }
  if !current.is_empty() {
    groups.push(current);
  }
  Ok(groups)
}

/// Sort kernel constants into canonical equivalence classes.
///
/// Iterative refinement (mirroring `sort_consts`,
/// `src/ix/compile.rs:2727`):
///
/// 1. Seed with all members in a single class.
/// 2. Build `KMutCtx` from the current partition.
/// 3. Sort each multi-element class structurally; group adjacent equals.
/// 4. Tiebreak each class by `id.addr` (kernel analogue of compile-side's