Make it easier to write tests involving fixed timesteps (#21705)

# Objective

- For running tests involving fixed timesteps, I want to advance the
time so that every call to `app.update()` triggers a fixed update
- Right now, the most precise way to do that to my knowledge is
  ```rust

app.insert_resource(TimeUpdateStrategy::ManualDuration(Time::<Fixed>::default().timestep()))
  ```
- But this is a bit clumsy, and also doesn't work when the fixed
timestep isn't at the default. Some more boilerplate would be needed in
the test setup to deal with that:
  ```rust

app.insert_resource(TimeUpdateStrategy::ManualDuration(app.world().resource::<Time<Fixed>>().timestep()))
  ```
- Good luck adapting this for the case when the fixed timestep ever
changes at runtime lol

## Solution

- Create an alternative strategy called
`TimeUpdateStrategy::FixedTimesteps` that advances time by the fixed
timestep automatically:
  ```rust
  // Now `app.update()` will run the fixed loop exactly once!
  app.insert_resource(TimeUpdateStrategy::FixedTimesteps(1))
  ```

## Testing

- None, as this is trivial

Author: janhohenheim

crates/bevy_time/src/fixed.rs

@@ -10,7 +10,7 @@ use crate::{time::Time, virt::Virtual};
 ///
 /// A specialization of the [`Time`] structure. **For method documentation, see
 /// [`Time<Fixed>#impl-Time<Fixed>`].**
-///     
+///
 /// It is automatically inserted as a resource by
 /// [`TimePlugin`](crate::TimePlugin) and updated based on
 /// [`Time<Virtual>`](Virtual). The fixed clock is automatically set as the

crates/bevy_time/src/lib.rs

@@ -118,6 +118,9 @@ pub enum TimeUpdateStrategy {
     ManualInstant(Instant),
     /// [`Time`] will be incremented by the specified [`Duration`] each frame.
     ManualDuration(Duration),
+    /// [`Time`] will be incremented by the fixed timestep each frame, multiplied by the specified factor `n`.
+    /// This means that a call to [`App::update`] will always run the fixed loop exactly n times.
+    FixedTimesteps(u32),
 }
 
 /// Channel resource used to receive time from the render world.
@@ -144,6 +147,7 @@ pub fn create_time_channels() -> (TimeSender, TimeReceiver) {
 pub fn time_system(
     mut real_time: ResMut<Time<Real>>,
     mut virtual_time: ResMut<Time<Virtual>>,
+    fixed_time: Res<Time<Fixed>>,
     mut time: ResMut<Time>,
     update_strategy: Res<TimeUpdateStrategy>,
     #[cfg(feature = "std")] time_recv: Option<Res<TimeReceiver>>,
@@ -175,6 +179,9 @@ pub fn time_system(
         }
         TimeUpdateStrategy::ManualInstant(instant) => real_time.update_with_instant(*instant),
         TimeUpdateStrategy::ManualDuration(duration) => real_time.update_with_duration(*duration),
+        TimeUpdateStrategy::FixedTimesteps(factor) => {
+            real_time.update_with_duration(fixed_time.timestep() * *factor);
+        }
     }
 
     update_virtual_time(&mut time, &mut virtual_time, &real_time);