Claude review: rust: maple_tree: implement Send and Sync for MapleTree

[Claude Code Review Bot <claude-review@example.com>]

Patch Review

**Send/Sync implementation — Correct**

The safety argument is sound:

```rust
// SAFETY: `MapleTree<T>` is `Send` if `T` is `Send` because `MapleTree` owns its elements.
unsafe impl<T: ForeignOwnable + Send> Send for MapleTree<T> {}
// SAFETY: `&MapleTree<T>` never hands out `&T`; all entry access is serialized
// by `ma_lock` or `&mut Guard`, so `T: Send` suffices (`T: Sync` not required).
unsafe impl<T: ForeignOwnable + Send> Sync for MapleTree<T> {}
```

This exactly matches the pattern used by `XArray` in the same codebase:
```rust
// SAFETY: `XArray<T>` has no shared mutable state so it is `Send` iff `T` is `Send`.
unsafe impl<T: ForeignOwnable + Send> Send for XArray<T> {}
// SAFETY: `XArray<T>` serialises the interior mutability it provides so it is `Sync` iff `T` is `Send`.
unsafe impl<T: ForeignOwnable + Send> Sync for XArray<T> {}
```

The reasoning for `Sync` only requiring `T: Send` (not `T: Sync`) is correct: `&MapleTree<T>` only allows access to the contained `T` values through the `MapleGuard`, which takes `&mut self` (exclusive access), so you never actually share a `&T` across threads simultaneously.

**MapleGuard !Send — Correct**

```rust
pub struct MapleGuard<'tree, T: ForeignOwnable> {
    tree: &'tree MapleTree<T>,
    // A held spinlock must be released on the same CPU that acquired it.
    _not_send: NotThreadSafe,
}
```

Making the guard `!Send` is essential for correctness. Spinlocks in the kernel must be released on the same CPU where they were acquired. This follows the same pattern used by `XArray`'s guard type. The comment is accurate and useful.

**Struct field access migration — Correct**

All references from `self.0` to `self.tree` are updated consistently:
- `self.0.ma_lock()` → `self.tree.ma_lock()` (in `Drop`)
- `self.0` → `self.tree` (in `ma_state`)
- `self.0.tree.get()` → `self.tree.tree.get()` (in `load`)

**Nit: Trailing comment in import**

```rust
    types::{
        ForeignOwnable,
        NotThreadSafe,
        Opaque, //
    },
```

The bare `//` after `Opaque` looks like a `rustfmt` trailing-comma guard (forces rustfmt to keep the multi-line format). This is a known idiom but it may look odd to reviewers unfamiliar with it. Not a blocking issue — it's a style preference — but worth noting since it was called out in review already and this is v2.

**Missing: `MapleTreeAlloc` Send/Sync**

`MapleTreeAlloc<T>` is `#[repr(transparent)]` around `MapleTree<T>`, so it *should* auto-derive `Send`/`Sync` once `MapleTree<T>` has them. The error trace in the commit message confirms the chain goes through `MapleTreeAlloc`, so this should work without explicit impls. This is fine as-is.

**Verdict: Patch is correct.** The safety invariants are well-reasoned, the pattern matches established precedent (`XArray`), and the `!Send` guard is properly handled. The only cosmetic nit is the `//` comment in the import block.

---
Generated by Claude Code Patch Reviewer