implement UniqueEntitySlice (bevyengine#17589)

# Objective

Follow-up to bevyengine#17549 and bevyengine#16547.

A large part of `Vec`s usefulness is behind its ability to be sliced,
like sorting f.e., so we want the same to be possible for
`UniqueEntityVec`.

## Solution

Add a `UniqueEntitySlice` type. It is a wrapper around `[T]`, and itself
a DST.

Because `mem::swap` has a `Sized` bound, DSTs cannot be swapped, and we
can freely hand out mutable subslices without worrying about the
uniqueness invariant of the backing collection!
`UniqueEntityVec` and the relevant `UniqueEntityIter`s now have methods
and trait impls that return `UniqueEntitySlice`s.
`UniqueEntitySlice` itself can deref into normal slices, which means we
can avoid implementing the vast majority of immutable slice methods.

Most of the remaining methods:
- split a slice/collection in further unique subsections/slices
- reorder the slice: `sort`, `rotate_*`, `swap`
- construct/deconstruct/convert pointer-like types: `Box`, `Arc`, `Rc`,
`Cow`
- are comparison trait impls

As this PR is already larger than I'd like, we leave several things to
follow-ups:
- `UniqueEntityArray` and the related slice methods that would return it
    - denoted by "chunk", "array_*" for iterators
- Methods that return iterators with `UniqueEntitySlice` as their item 
    - `windows`, `chunks` and `split` families
- All methods that are capable of actively mutating individual elements.
While they could be offered unsafely, subslicing makes their safety
contract weird enough to warrant its own discussion.
- `fill_with`, `swap_with_slice`, `iter_mut`, `split_first/last_mut`,
`select_nth_unstable_*`

Note that `Arc`, `Rc` and `Cow` are not fundamental types, so even if
they contain `UniqueEntitySlice`, we cannot write direct trait impls for
them.
On top of that, `Cow` is not a receiver (like `self: Arc<Self>` is) so
we cannot write inherent methods for it either.

Author: Victoronz

crates/bevy_ecs/src/entity/entity_set.rs

@@ -13,7 +13,7 @@ use core::{
     option, result,
 };
 
-use super::Entity;
+use super::{Entity, UniqueEntitySlice};
 
 use bevy_platform_support::sync::Arc;
 
@@ -350,6 +350,7 @@ impl<I: EntitySetIterator> UniqueEntityIter<I> {
         Self { iter }
     }
 }
+
 impl<I: Iterator<Item: TrustedEntityBorrow>> UniqueEntityIter<I> {
     /// Constructs a [`UniqueEntityIter`] from an iterator unsafely.
     ///
@@ -359,6 +360,26 @@ impl<I: Iterator<Item: TrustedEntityBorrow>> UniqueEntityIter<I> {
     pub unsafe fn from_iterator_unchecked(iter: I) -> Self {
         Self { iter }
     }
+
+    /// Returns the inner `I`.
+    pub fn into_inner(self) -> I {
+        self.iter
+    }
+
+    /// Returns a reference to the inner `I`.
+    pub fn as_inner(&self) -> &I {
+        &self.iter
+    }
+
+    /// Returns a mutable reference to the inner `I`.
+    ///
+    /// # Safety
+    ///
+    /// `self` must always contain an iterator that yields unique elements,
+    /// even while this reference is live.
+    pub unsafe fn as_mut_inner(&mut self) -> &mut I {
+        &mut self.iter
+    }
 }
 
 impl<I: Iterator<Item: TrustedEntityBorrow>> Iterator for UniqueEntityIter<I> {
@@ -394,6 +415,24 @@ impl<T, I: Iterator<Item: TrustedEntityBorrow> + AsRef<[T]>> AsRef<[T]> for Uniq
     }
 }
 
+impl<T: TrustedEntityBorrow, I: Iterator<Item: TrustedEntityBorrow> + AsRef<[T]>>
+    AsRef<UniqueEntitySlice<T>> for UniqueEntityIter<I>
+{
+    fn as_ref(&self) -> &UniqueEntitySlice<T> {
+        // SAFETY: All elements in the original slice are unique.
+        unsafe { UniqueEntitySlice::from_slice_unchecked(self.iter.as_ref()) }
+    }
+}
+
+impl<T: TrustedEntityBorrow, I: Iterator<Item: TrustedEntityBorrow> + AsMut<[T]>>
+    AsMut<UniqueEntitySlice<T>> for UniqueEntityIter<I>
+{
+    fn as_mut(&mut self) -> &mut UniqueEntitySlice<T> {
+        // SAFETY: All elements in the original slice are unique.
+        unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.iter.as_mut()) }
+    }
+}
+
 // Default does not guarantee uniqueness, meaning `I` needs to be EntitySetIterator.
 impl<I: EntitySetIterator + Default> Default for UniqueEntityIter<I> {
     fn default() -> Self {

crates/bevy_ecs/src/entity/mod.rs

@@ -66,6 +66,10 @@ mod index_set;
 pub use index_map::EntityIndexMap;
 pub use index_set::EntityIndexSet;
 
+mod unique_slice;
+
+pub use unique_slice::*;
+
 use crate::{
     archetype::{ArchetypeId, ArchetypeRow},
     identifier::{