Commit and status no longer slow down with the number of heads 07eb99be126e

        // The snapshot already loaded the working copy's base; when that also

        // holds every bookmark head, it is the state to extend.

        let mut st = if old_heads.iter().all(|h| snap.base.contains(h)) {

            snap.base

        } else {

            self.load_state(&all)?

        };

    /// Maximal elements among `hashes` (those not in the closure of another),

    /// sorted. One walk down from all of them at once: whatever the walk

    /// reaches is below some other element. Linear in the changes reached,

    /// where comparing every pair's closures was quadratic in the number

    /// of heads, which a bookmark of independent changes has many of.

        let mut below: HashSet<ChangeHash> = HashSet::new();

        let mut stack: Vec<ChangeHash> = set

            .iter()

            .filter_map(|h| self.changes.get(h))

            .flat_map(|c| c.deps.iter().copied())

            .collect();

        while let Some(d) = stack.pop() {

            if below.insert(d) {

                if let Some(c) = self.changes.get(&d) {

                    stack.extend(c.deps.iter().copied());

                }

            }

        }

        set.into_iter().filter(|h| !below.contains(h)).collect()

    /// The one-walk `maximal` agrees with the definition (not in the

    /// closure of another element) on random graphs, with repeated and

    /// unknown hashes among the input.

    #[test]

    fn maximal_matches_its_definition() {

        use rand::{Rng, SeedableRng};

        let mut rng = rand::rngs::StdRng::seed_from_u64(7);

        for _ in 0..20 {

            let mut st = State::new();

            let mut all: Vec<ChangeHash> = Vec::new();

            for _ in 0..60 {

                let deps: Vec<ChangeHash> =

                    all.iter().copied().filter(|_| rng.gen_bool(0.05)).collect();

                all.push(st.add(change(deps, vec![], vec![])).unwrap());

            }

            let mut pick: Vec<ChangeHash> =

                all.iter().copied().filter(|_| rng.gen_bool(0.4)).collect();

            pick.extend(pick.clone().into_iter().take(3));

            pick.push(ObjectRef([0xee; 32]));

            let set: BTreeSet<ChangeHash> = pick.iter().copied().collect();

            let want: Vec<ChangeHash> = set

                .iter()

                .filter(|h| !set.iter().any(|o| o != *h && st.closure(o).contains(h)))

                .copied()

                .collect();

            assert_eq!(st.maximal(&pick), want);

            assert_eq!(st.maximal(&all), st.heads());

        }

    }

- [x] O10a Heads at scale (first part of O10): `State::maximal` compared every pair of heads (quadratic; about 1.5 s per call at 4 500 heads, called three times per commit); now one walk. Commit reuses the snapshot's base state instead of loading it again.

- [ ] O10b Snapshot fast path (rest of O10): at 10 000 files and 5 000 changes a commit takes 3.8 s and a clean status 3.0 s, because every snapshot loads and materializes the whole base state (about 75 ms load, 75 ms materialize, 50 ms walk at 4 000 files). Skip load and materialize when every file's stat matches a manifest written for the same base; make the base state lazy for callers that need it; cache the materialized snapshot per state. Target the spec §25 numbers.