Improve parallel

[rikhuijzer]

This improves upon #45 by enabling parallel processing only for the top-level call. Any nested calls use single-threaded. Time is now 22.2 ms so about a 7% improvement.

The problem with the old/current approach is that the par_iter starts but then is called another time below. Much better could be to gather all ops together and then call par_iter once. See https://fasterthanli.me/articles/recursive-iterators-rust and https://blog.danieljanus.pl/2023/07/20/iterating-trees/.

I've tried an iterator like

/// Return an iterator over `op` and all (indirect) children of `op`.
pub fn ops(op: Shared<dyn Op>) -> Box<dyn Iterator<Item = Shared<dyn Op>>> {
    let start = vec![op.clone()].into_iter();

    fn block_ops(block: Shared<Block>) -> Box<dyn Iterator<Item = Shared<dyn Op>>> {
        Box::new(
            block
                .rd()
                .ops()
                .rd()
                .clone()
                .into_iter()
                .flat_map(|op| ops(op)),
        )
    }
    if let Some(region) = op.rd().region() {
        let rest = region.rd().blocks().into_iter().flat_map(block_ops);
        Box::new(start.chain(rest))
    } else {
        Box::new(start)
    }
}

but since it is a Box, rayon needs it collected first so then just recursively calling the apply_rewrite function seems to not be that bad.