Faster FilteredEntity(Ref|Mut) and Entity(Ref|Mut)Except by borrowing Access (#20111)

# Objective

Improve the performance of queries using `FilteredEntityRef`,
`FilteredEntityMut`, `EntityRefExcept`, and `EntityMutExcept`. In
particular, this appears to speed up `bevy_animation::animate_targets`
by 10% in many-foxes.

`FilteredEntity(Ref|Mut)` needs to store an `Access` to determine which
components may be accessed. Prior to #15396, this required cloning the
`Access` for each instance. Now, we can borrow the `Access` from the
query state and make cheap pointer copies.

`Entity(Ref|Mut)Except` avoided needing to clone an `Access` by calling
functions on the `Bundle` trait. Unfortunately, that meant we needed to
convert from a type to a `ComponentId` for every component in the bundle
on every check. Now, we can do those conversions up front and pass
references to an `Access`.

Finally, fix a bug where `Entity(Ref|Mut)Except` would not initialize
their components during `init_state`. I noticed this while updating
`init_state` and fixed it while I was there. That was normally harmless
because the components would be registered elsewhere, but a system like
`fn system(_q1: Query<EntityMutExcept<C>>, _q2: Query<&mut C>) {}` would
fail to find the `ComponentId` for `C` and not exclude it from the
access for `q1`, and then panic with conflicting access from `q2`.

## Solution

Change `FilteredEntityRef` and `FilteredEntityMut` to store `&'s Access`
instead of `Access`, and change `EntityRefExcept` and `EntityMutExcept`
to store an extra `&'s Access`.

This adds the `'s` lifetime to those four types, and most changes are
adding lifetimes as appropriate.

Change the `WorldQuery::State` for `Entity(Ref|Mut)Except` to store an
`Access` that can be borrowed from, replacing the
`SmallVec<[ComponentId; 4]>` that was used only to set the query access.

To support the conversions from `EntityRef` and `EntityMut`, we need to
be able to create a `&'static Access` for read-all or write-all. I could
not change `fn read_all_components()` to be `const` because it called
the non-`const` `FixedBitSet::clear()`, so I created separate
constructor functions.

## Testing

Ran `cargo run --example many_foxes --features bevy/trace_tracy
--release` before and after, and compared the results of
`animate_targets`, since that is the only in-engine use of
`EntityMutExcept` and was the motivation for creating it.

Yellow is this PR, red is main: 

<img width="695" height="690" alt="image"
src="https://github.com/user-attachments/assets/24531a3f-65bf-46d0-baa5-29ea9e56b16a"
/>

Author: chescock

crates/bevy_animation/src/animation_curves.rs

@@ -408,10 +408,7 @@ impl<A: Animatable> AnimationCurveEvaluator for AnimatableCurveEvaluator<A> {
         self.evaluator.push_blend_register(weight, graph_node)
     }
 
-    fn commit<'a>(
-        &mut self,
-        mut entity: AnimationEntityMut<'a>,
-    ) -> Result<(), AnimationEvaluationError> {
+    fn commit(&mut self, mut entity: AnimationEntityMut) -> Result<(), AnimationEvaluationError> {
         let property = self.property.get_mut(&mut entity)?;
         *property = self
             .evaluator
@@ -596,10 +593,7 @@ impl AnimationCurveEvaluator for WeightsCurveEvaluator {
         Ok(())
     }
 
-    fn commit<'a>(
-        &mut self,
-        mut entity: AnimationEntityMut<'a>,
-    ) -> Result<(), AnimationEvaluationError> {
+    fn commit(&mut self, mut entity: AnimationEntityMut) -> Result<(), AnimationEvaluationError> {
         if self.stack_morph_target_weights.is_empty() {
             return Ok(());
         }
@@ -905,10 +899,7 @@ pub trait AnimationCurveEvaluator: Downcast + Send + Sync + 'static {
     ///
     /// The property on the component must be overwritten with the value from
     /// the stack, not blended with it.
-    fn commit<'a>(
-        &mut self,
-        entity: AnimationEntityMut<'a>,
-    ) -> Result<(), AnimationEvaluationError>;
+    fn commit(&mut self, entity: AnimationEntityMut) -> Result<(), AnimationEvaluationError>;
 }
 
 impl_downcast!(AnimationCurveEvaluator);

crates/bevy_animation/src/lib.rs

@@ -1021,8 +1021,8 @@ pub fn advance_animations(
 }
 
 /// A type alias for [`EntityMutExcept`] as used in animation.
-pub type AnimationEntityMut<'w> =
-    EntityMutExcept<'w, (AnimationTarget, AnimationPlayer, AnimationGraphHandle)>;
+pub type AnimationEntityMut<'w, 's> =
+    EntityMutExcept<'w, 's, (AnimationTarget, AnimationPlayer, AnimationGraphHandle)>;
 
 /// A system that modifies animation targets (e.g. bones in a skinned mesh)
 /// according to the currently-playing animations.

crates/bevy_ecs/src/query/access.rs

@@ -165,6 +165,32 @@ impl<T: SparseSetIndex> Access<T> {
         }
     }
 
+    /// Creates an [`Access`] with read access to all components.
+    /// This is equivalent to calling `read_all()` on `Access::new()`,
+    /// but is available in a `const` context.
+    pub(crate) const fn new_read_all() -> Self {
+        let mut access = Self::new();
+        access.reads_all_resources = true;
+        // Note that we cannot use `read_all_components()`
+        // because `FixedBitSet::clear()` is not `const`.
+        access.component_read_and_writes_inverted = true;
+        access
+    }
+
+    /// Creates an [`Access`] with read access to all components.
+    /// This is equivalent to calling `read_all()` on `Access::new()`,
+    /// but is available in a `const` context.
+    pub(crate) const fn new_write_all() -> Self {
+        let mut access = Self::new();
+        access.reads_all_resources = true;
+        access.writes_all_resources = true;
+        // Note that we cannot use `write_all_components()`
+        // because `FixedBitSet::clear()` is not `const`.
+        access.component_read_and_writes_inverted = true;
+        access.component_writes_inverted = true;
+        access
+    }
+
     fn add_component_sparse_set_index_read(&mut self, index: usize) {
         if !self.component_read_and_writes_inverted {
             self.component_read_and_writes.grow_and_insert(index);