Part of #1429: Edit and Object commands on many objects take time linear in the document

Delete, Cut, Group, Make Compound Path, Make Clipping Mask, Send to
Current Layer, Ungroup and Release Compound Path removed, inserted or
moved one object at a time. duplicate_in inserted one copy at a time;
Duplicate, Copy in the Move, Rotate, Scale, Reflect and Shear dialogs,
Transform Again after a copy, Transform Each with Copy, the perspective
copies and each move of an Alt-drag call it. Each insertion or removal
moved the later objects of the same layer or group to other indices.
The next lookup by id then walked the tree, and after every fourth such
walk Document::index_path rebuilt the whole lookup cache. Each command
did work that grew with the number of objects times the size of the
document: with 25,000 rectangles selected, a release build of
vectorcraft-cli took 7.2 s to group them and 11.5 s to copy them with
object.transform.

Document::remove_many, Document::wrap and Document::insert_beside
remove nodes, wrap them in a new node, or put nodes directly above or
in place of their anchors, in one pass over the children of each
parent. Each finds the nodes with one index_paths call, checks every id
before it changes anything, and clears the lookup cache once. The
commands above use them. The objects keep their order, the copies take
their ids in the same order, and the selection, the undo step and the
journal are the same. duplicate_in still copies one root at a time when
a root is listed twice or lies inside another root. A release build
with this change groups the 25,000 rectangles in 27 ms and copies them
in 121 ms.

Docs: docs/target-app-parity.md.

crates/engine/src/cmd/edit.rs

@@ -384,9 +384,7 @@ fn clear(s: &mut Session, p: &Value) -> Result<Value> {
         return ok();
     }
     s.edit("Clear", |d, sel| {
-        for id in &ids {
-            d.remove(*id)?;
-        }
+        d.remove_many(&ids)?;
         if with_guides {
             let gone = sel.guides.clone();
             d.retain_guides(sel, |i, _| !gone.contains(&i));
@@ -560,16 +558,35 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() }))
 }
 
-/// Duplicate `roots` directly above each original, transform the copies, select them.
+/// Duplicate `roots` directly above each original, transform the copies, select them. The copies
+/// take new ids in the order of `roots`. Roots listed twice, or inside another root, are copied one
+/// at a time: each copy is made from the document as the copies before it left it.
 pub(crate) fn duplicate_in(d: &mut Document, sel: &mut vectorcraft_doc::Selection, roots: &[NodeId], xf: Affine) -> Result<Vec<NodeId>> {
-    let mut out = vec![];
-    for id in roots {
-        let Some((par, idx, _)) = d.position(*id) else { continue };
-        let Some(n) = d.node(*id).cloned() else { continue };
-        let mut c = d.reid(&n);
-        c.transform(xf, true);
-        out.push(d.insert(par, idx + 1, c)?);
-    }
+    let paths = d.index_paths(roots.iter().copied());
+    let mut found: Vec<_> = roots.iter().filter_map(|id| paths.get(id)).collect();
+    found.sort_unstable();
+    let out = if found.windows(2).all(|w| !w[1].starts_with(w[0])) {
+        let mut copies = Vec::with_capacity(roots.len());
+        for id in roots {
+            let Some(n) = paths.get(id).and_then(|p| d.node_at(p)).cloned() else { continue };
+            let mut c = d.reid(&n);
+            c.transform(xf, true);
+            copies.push((*id, vec![c]));
+        }
+        let out: Vec<NodeId> = copies.iter().flat_map(|(_, c)| c.iter().map(|n| n.id)).collect();
+        d.insert_beside(copies, false)?;
+        out
+    } else {
+        let mut out = vec![];
+        for id in roots {
+            let Some((par, idx, _)) = d.position(*id) else { continue };
+            let Some(n) = d.node(*id).cloned() else { continue };
+            let mut c = d.reid(&n);
+            c.transform(xf, true);
+            out.push(d.insert(par, idx + 1, c)?);
+        }
+        out
+    };
     sel.set(out.iter().copied());
     Ok(out)
 }