Move implementations of Query methods from QueryState to Query. (#17822)

# Objective

Simplify the API surface by removing duplicated functionality between
`Query` and `QueryState`.

Reduce the amount of `unsafe` code required in `QueryState`.  

This is a follow-up to #15858.

## Solution

Move implementations of `Query` methods from `QueryState` to `Query`.
Instead of the original methods being on `QueryState`, with `Query`
methods calling them by passing the individual parameters, the original
methods are now on `Query`, with `QueryState` methods calling them by
constructing a `Query`.

This also adds two `_inner` methods that were missed in #15858:
`iter_many_unique_inner` and `single_inner`.

One goal here is to be able to deprecate and eventually remove many of
the methods on `QueryState`, reducing the overall API surface. (I
expected to do that in this PR, but this change was large enough on its
own!) Now that the `QueryState` methods each consist of a simple
expression like `self.query(world).get_inner(entity)`, a future PR can
deprecate some or all of them with simple migration instructions.

The other goal is to reduce the amount of `unsafe` code. The current
implementation of a read-only method like `QueryState::get` directly
calls the `unsafe fn get_unchecked_manual` and needs to repeat the proof
that `&World` has enough access. With this change, `QueryState::get` is
entirely safe code, with the proof that `&World` has enough access done
by the `query()` method and shared across all read-only operations.

## Future Work

The next step will be to mark the `QueryState` methods as
`#[deprecated]` and migrate callers to the methods on `Query`.

Author: chescock

crates/bevy_ecs/src/query/error.rs

@@ -17,7 +17,7 @@ pub enum QueryEntityError<'w> {
     NoSuchEntity(Entity, EntityDoesNotExistDetails),
     /// The [`Entity`] was requested mutably more than once.
     ///
-    /// See [`QueryState::get_many_mut`](crate::query::QueryState::get_many_mut) for an example.
+    /// See [`Query::get_many_mut`](crate::system::Query::get_many_mut) for an example.
     AliasedMutability(Entity),
 }
 

crates/bevy_ecs/src/query/iter.rs

@@ -849,6 +849,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> QueryIter<'w, 's, D, F> {
         // SAFETY:
         // `self.world` has permission to access the required components.
         // The original query iter has not been iterated on, so no items are aliased from it.
+        // `QueryIter::new` ensures `world` is the same one used to initialize `query_state`.
         let query_lens = unsafe { query_lens_state.query_unchecked_manual(world) }.into_iter();
         let mut keyed_query: Vec<_> = query_lens
             .map(|(key, entity)| (key, NeutralOrd(entity)))
@@ -1683,6 +1684,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter, I: Iterator<Item: EntityBorrow>>
         // SAFETY:
         // `self.world` has permission to access the required components.
         // The original query iter has not been iterated on, so no items are aliased from it.
+        // `QueryIter::new` ensures `world` is the same one used to initialize `query_state`.
         let query_lens = unsafe { query_lens_state.query_unchecked_manual(world) }
             .iter_many_inner(self.entity_iter);
         let mut keyed_query: Vec<_> = query_lens

crates/bevy_ecs/src/query/par_iter.rs

@@ -94,7 +94,8 @@ impl<'w, 's, D: QueryData, F: QueryFilter> QueryParIter<'w, 's, D, F> {
             // at the same time.
             unsafe {
                 self.state
-                    .iter_unchecked_manual(self.world, self.last_run, self.this_run)
+                    .query_unchecked_manual_with_ticks(self.world, self.last_run, self.this_run)
+                    .into_iter()
                     .fold(init, func);
             }
         }
@@ -106,7 +107,8 @@ impl<'w, 's, D: QueryData, F: QueryFilter> QueryParIter<'w, 's, D, F> {
                 // SAFETY: See the safety comment above.
                 unsafe {
                     self.state
-                        .iter_unchecked_manual(self.world, self.last_run, self.this_run)
+                        .query_unchecked_manual_with_ticks(self.world, self.last_run, self.this_run)
+                        .into_iter()
                         .fold(init, func);
                 }
             } else {
@@ -262,12 +264,8 @@ impl<'w, 's, D: ReadOnlyQueryData, F: QueryFilter, E: EntityBorrow + Sync>
             // at the same time.
             unsafe {
                 self.state
-                    .iter_many_unchecked_manual(
-                        &self.entity_list,
-                        self.world,
-                        self.last_run,
-                        self.this_run,
-                    )
+                    .query_unchecked_manual_with_ticks(self.world, self.last_run, self.this_run)
+                    .iter_many_inner(&self.entity_list)
                     .fold(init, func);
             }
         }
@@ -279,12 +277,8 @@ impl<'w, 's, D: ReadOnlyQueryData, F: QueryFilter, E: EntityBorrow + Sync>
                 // SAFETY: See the safety comment above.
                 unsafe {
                     self.state
-                        .iter_many_unchecked_manual(
-                            &self.entity_list,
-                            self.world,
-                            self.last_run,
-                            self.this_run,
-                        )
+                        .query_unchecked_manual_with_ticks(self.world, self.last_run, self.this_run)
+                        .iter_many_inner(&self.entity_list)
                         .fold(init, func);
                 }
             } else {
@@ -430,12 +424,8 @@ impl<'w, 's, D: QueryData, F: QueryFilter, E: TrustedEntityBorrow + Sync>
             // at the same time.
             unsafe {
                 self.state
-                    .iter_many_unique_unchecked_manual(
-                        self.entity_list,
-                        self.world,
-                        self.last_run,
-                        self.this_run,
-                    )
+                    .query_unchecked_manual_with_ticks(self.world, self.last_run, self.this_run)
+                    .iter_many_unique_inner(self.entity_list)
                     .fold(init, func);
             }
         }
@@ -447,12 +437,8 @@ impl<'w, 's, D: QueryData, F: QueryFilter, E: TrustedEntityBorrow + Sync>
                 // SAFETY: See the safety comment above.
                 unsafe {
                     self.state
-                        .iter_many_unique_unchecked_manual(
-                            self.entity_list,
-                            self.world,
-                            self.last_run,
-                            self.this_run,
-                        )
+                        .query_unchecked_manual_with_ticks(self.world, self.last_run, self.this_run)
+                        .iter_many_unique_inner(self.entity_list)
                         .fold(init, func);
                 }
             } else {