Add optimized grow()/shrink() functions to Allocator implementation for pool

[ensh63]

Proposed changes

If resizing is requested for the last allocation in the pool, it may be possible to adjust pool data and avoid any real allocations.

Checklist

Before creating a PR, run through this checklist and mark each as complete.

• I have written my commit messages in the Conventional Commits format.
• I have read the CONTRIBUTING doc
• I have added tests (when possible) that prove my fix is effective or that my feature works
• I have checked that all unit tests pass after adding my changes
• I have updated necessary documentation
• I have rebased my branch onto main
• I will ensure my PR is targeting the main branch and pulling from my branch from my own fork

[Copilot]

Pull Request Overview

This PR implements optimized grow() and shrink() functions for the Pool allocator that can avoid real allocations when resizing the last allocation in the pool by simply adjusting the pool's last pointer.

• Adds grow() method that can expand the last allocation in-place if there's sufficient space
• Adds shrink() method that can contract the last allocation in-place by moving the pool's last pointer backward
• Falls back to allocate-copy-deallocate pattern when in-place resizing isn't possible

---

_{Tip: Customize your code reviews with copilot-instructions.md. Create the file or learn how to get started.}

[Copilot]

Redundant unsafe block: the entire function is already declared as unsafe, so this inner unsafe block is unnecessary.

Suggested change

	}
	ptr::copy_nonoverlapping(
	ptr.as_ptr(),
	new_ptr.as_ptr().cast(),
	old_layout.size(),
	);
	self.deallocate(ptr, old_layout);

[pchickey]

The right fix is to upgrade the crate to edition 2024, where the code, as written, is required by rustc.

[Copilot]

Redundant unsafe block: the entire function is already declared as unsafe, so this inner unsafe block is unnecessary.

Suggested change

	}
	ptr::copy_nonoverlapping(
	ptr.as_ptr(),
	new_ptr.as_ptr().cast(),
	old_layout.size(),
	);
	self.deallocate(ptr, old_layout);

[xeioex]

Some minor nitpicks, for the commit log
Making the commit log shorter and adding a new line for the body.

`feat: Add optimized grow()/shrink() functions for Pool

If resizing is requested for the last allocation in the pool, it may be
possible to adjust pool data and avoid any real allocations.`

?

Otherwise looks good.

[bavshin-f5]

1. What about Allocator::grow_zeroed?
2. new_layout.size() >= old_layout.size() is a safety requirement of the Allocator::grow interface. It is acceptable to assume that the opposite never happens and limit handling of this case to debug_assert.
3. old_layout.size() == new_layout.size() does not guarantee that old_layout == new_layout.
4. It seems to me that all 3 methods could be generalized to

   #[inline(always)]
   fn resize_in_place(&self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout) -> Option<NonNull<[u8]>> { ... }
   
   fn grow(...) {
        ...
        if let Some(new_ptr) = self.resize_in_place(...) {
            Ok(new_ptr)
         } else {
             ...
         }
   }

[xeioex]

if new_layout.size() >= old_layout.size()

old_layout.size() - new_layout.size() will be negative?

[xeioex]

ptr::write_bytes(
    new_ptr.as_ptr().cast::<u8>().add(old_layout.size()),  // Start at end of old data
    0,
    new_layout.size() - old_layout.size(),  // Zero the NEW bytes
)