Checkout through the state index; two indexes kept; racy files hashed in parallel (refs #41) 638fb21420d7

        // for the files that must be written, and dropped after. It becomes

        // the working copy's base, which the state index holds.

        let mut target = self.load_state_indexed(heads)?;

/// How many state indexes a workspace keeps.

const STATE_INDEXES_KEPT: usize = 2;

    /// The state index of the state with these heads: this workspace keeps

    /// the last few it used, named by their heads, so moving between two

    /// states finds both.

    fn state_index_path(&self, heads: &[ChangeHash]) -> PathBuf {

        let mut heads = heads.to_vec();

        heads.sort();

        let mut h = blake3::Hasher::new();

        for c in &heads {

            h.update(&c.0);

        }

        self.oxy.join("index").join(format!(

            "{}{}",

            self.state_index_prefix(),

            &h.finalize().to_hex()[..16]

        ))

    fn state_index_prefix(&self) -> String {

        format!("state-{}-", self.workspace.to_hex())

    }

    /// This workspace's state indexes, newest first.

    fn state_indexes(&self) -> Vec<PathBuf> {

        let prefix = self.state_index_prefix();

        let mut found: Vec<(std::time::SystemTime, PathBuf)> = fs::read_dir(self.oxy.join("index"))

            .into_iter()

            .flatten()

            .flatten()

            .filter(|e| e.file_name().to_string_lossy().starts_with(&prefix))

            .filter_map(|e| Some((e.metadata().ok()?.modified().ok()?, e.path())))

            .collect();

        found.sort_by_key(|f| std::cmp::Reverse(f.0));

        found.into_iter().map(|(_, p)| p).collect()

    }

        if let Some((st, heads)) = self.read_state_index(deps) {

    /// The index of `deps` if there is one, else the newest, which the

    /// caller may bring up to date.

    fn read_state_index(&self, deps: &[ChangeHash]) -> Option<(State, Vec<ChangeHash>)> {

        let exact = self.state_index_path(deps);

        let bytes = match fs::read(&exact) {

            Ok(b) => {

                // Used now: the newest, so the last to be dropped.

                let _ = fs::File::options()

                    .write(true)

                    .open(&exact)

                    .and_then(|f| f.set_modified(std::time::SystemTime::now()));

                b

            }

            Err(_) => fs::read(self.state_indexes().first()?).ok()?,

        };

        let mut f = fs::File::open(self.state_indexes().first()?).ok()?;

        let path = self.state_index_path(&heads);

        // The last two used: the index of a state moved away from stays for

        // a move back. Older ones (and the unnamed one of before) go.

        for old in self.state_indexes().iter().skip(STATE_INDEXES_KEPT) {

            let _ = fs::remove_file(old);

        }

        let _ = fs::remove_file(

            self.oxy

                .join("index")

                .join(format!("state-{}", self.workspace.to_hex())),

        );

        // Entries in the racy window are hashed, in parallel (a checkout

        // just wrote them all).

        use rayon::prelude::*;

        let racy: Vec<(&String, &ManifestEntry)> = m

            .entries

            .iter()

            .filter(|(_, e)| e.mtime_ns + 2_000_000_000 >= m.written_ns)

            .collect();

        let root = &self.root;

        let changed = racy.par_iter().find_any(|(rel, e)| {

            let path = root.join(rel.as_str());

            !same

        });

        if let Some((rel, _)) = changed {

            return not(&format!("{rel} changed within the racy window"));

    let reading = crate::timing::phase("graphs: read changes and blobs");

    drop(reading);

    let lines = crate::timing::phase("graphs: lines of inserts");

    drop(lines);

    let _t = crate::timing::phase("graphs: build");