This crash is due to buckets being deallocated while traversing the tree. Since in-order traversal is used the parent is destroyed before the right child is visited.

        fn freeRetainedMetadata(self: *Self) void {
                // ...
                var empty_it = self.empty_buckets.inorderIterator();
                while (empty_it.next()) |node| {
                    var bucket = node.key;
                    if (config.never_unmap) {
                        // free page that was intentionally leaked by never_unmap
                        self.backing_allocator.free(bucket.page[0..page_size]);
                    }
                    // alloc_cursor was set to slot count when bucket added to empty_buckets
                    self.freeBucket(bucket, @divExact(page_size, bucket.alloc_cursor));
                    self.bucket_node_pool.destroy(node);  // <-- PARENT DESTROYED BEFORE VISITING RIGHT CHILD
                }
                self.empty_buckets.root = null;
            }
        }

The way I see it there are 3 possible solutions:

1. Switch to post-order traversal, then both children are deallocated before the parent.
2. Make the in-order traversal support deallocation of nodes during iteration.
3. Save the nodes in some other data structure (possibly a linked list) and destroy them at the end after freeing all the buckets.

To me option 1 sounds the best unless there is a specific reason in-order traversal is being used here.

In-order iteration was purposefully used for detectLeaks since it would then mirror the order of the allocations that were made, but there's no reason that freeRetainedMetadata has to use in-order iteration. Option 1 sounds good to me as well.

I went with a fourth approach that explicitly removes nodes from the tree before destroying them. This causes extra work (walking to the smallest element each iteration and rotations for nodes with right branches), but has the benefit of not creating a public API that could very easily be misused.

The problem with the post-order iterator approach is that it invalidates the tree itself when the first node is deallocated. The iteration only works because each node is being deallocated, but the tree itself cannot be reused. There's probably a better solution that makes it more clear that this iterator should only be used to:

1. Iterate and look at the nodes of the tree (here the InorderIterator is probably better)
2. Destroy each node of the tree.

Related to this the InorderIterator should probably return const pointers since modifying nodes can very easily lead to bugs, such as this use-after-free.