Function cheap_beta_reduce

crates/kernel/src/subst.rs:512–588

Cheap beta reduction: peephole-reduce `App(λ...λ. body, args)` shapes without invoking the full [`subst`] machinery in trivial cases. Mirrors `lean4lean`'s `Expr.cheapBetaReduce` (refs/lean4lean/Lean4Lean/Instantiate.lean:8-27) and the C++ kernel's `cheap_beta_reduce` (refs/lean4/src/kernel/instantiate.cpp:211). For a spine `App(λx_0 ... λx_{n-1}. body, a_0, ..., a_{m-1})` we peel `i = min(n, m)

(
  env: &mut InternTable<M>,
  e: &KExpr<M>,
)

  /// referenced by many variables; spine args survive multiple machine
  /// re-entries), and without a global content-addressed memo this is
  /// what keeps each shared closure's substitution from re-running.
  readback: OnceCell<KExpr<M>>,
}

impl<M: KernelMode> Clo<M> {
  pub(crate) fn new(e: KExpr<M>, env: MEnv<M>) -> Self {
    Clo { e, env, readback: OnceCell::new() }
  }

  /// Closure over the empty environment (a plain expression).
  pub(crate) fn closed(e: KExpr<M>) -> Self {
    Clo::new(e, MEnv::empty())
  }
}

struct MEnvNode<M: KernelMode> {
  head: Arc<Clo<M>>,
  tail: MEnv<M>,
}

/// Persistent cons-list environment: O(1) push with structural sharing
/// across the closures captured at each binder. `len` is carried on the
/// handle — recomputing it per suffix was a measured cost on the IxVM
/// port of this machine.
pub(crate) struct MEnv<M: KernelMode> {
  node: Option<Arc<MEnvNode<M>>>,
  len: u64,
}

// Manual impl: `#[derive(Clone)]` would demand `M: Clone`.
impl<M: KernelMode> Clone for MEnv<M> {
  fn clone(&self) -> Self {
    MEnv { node: self.node.clone(), len: self.len }
  }
}

impl<M: KernelMode> MEnv<M> {
  pub(crate) fn empty() -> Self {
    MEnv { node: None, len: 0 }
  }

  pub(crate) fn len(&self) -> u64 {
    self.len
  }

  pub(crate) fn push(&self, c: Arc<Clo<M>>) -> Self {
    MEnv {
      node: Some(Arc::new(MEnvNode { head: c, tail: self.clone() })),
      len: self.len + 1,
    }
  }

  /// O(i) cons-list walk; `i` must be `< self.len()`. Machine variable
  /// lookups are typically near the front (recently pushed args).
  pub(crate) fn get(&self, i: u64) -> &Arc<Clo<M>> {
    let mut node = self.node.as_ref().expect("MEnv::get out of range");
    let mut i = i;
    while i > 0 {