Feature: Add systems to an app / plugin that run during build step

[Weibye]

Feature Description

The system is a really good pattern to interact with the world and something all users learn.

1. We have system that run during the runtime of the app.
2. We have startup_system that runs during the startup-phase of the app
3. We don't have any ability to run a system during the build phase of the plugin or app.

Thus I would like to propose a formalized concept of build_system that are run during the build phase of the app. End-result api could look something like pictured below:

impl Plugin for MyPlugin {
    fn build(&self, app: &mut App) {
        app.add_build_system(configure_plugin)
            .add_build_system(some_other_build_system)
            .add_startup_system(spawn_scene)
            .add_system(player_movement);
    }
}

• Any commands queued during build should be executed before the application starts and the first startup-system begins.
• As much as possible, existing tools and interfaces should be reused:
  • Ordering, labels, stages, states?
• system ordering and scheduler can be reused?
• This could maybe help solve Order independence of App construction #1255 ?
• Relates to Plugin - setup resource #2988 (and we could name this concept setup_system to adhere to the same naming scheme)

Context

The idea is primarily driven by my work over at #4947 where plugins like bevy_winit and bevy_render has a lot of "custom code" during plugin setup that I would really like to abstract into systems. It would be very helpful if the entire plugin could be described by just a series of .add_build_system / .add_startup_system / .add_system and not require that the user use direct world access to perform more esoteric operations during build. (Though that ability should not be taken away).

It would be easier to reason about the plugin as a whole, but also more approachable for new contributors wanting to understand how everything works.

Alternatives

The SystemState api is awesome, so thanks to everyone who made that happen ❤️

The following is my current approach to create "build systems" and it works, kinda, except a bit heavy on boilerplate and quickly run into borrow-checker shenanigans when combining with direct-world operations. (Maybe this is just me making mistakes)

Biggest limitation with doing this is that any commands queued up don't run before the start of the startup systems

impl Plugin for MyPlugin {
    fn build(&self, app: &mut App) {
        let mut system_state: SystemState<(
            Commands,
            EventReader<SomeEvent>,
            Query<&mut MyComponent>,
        )> = SystemState::new(&mut app.world);
        let (
            mut commands,
            mut event_reader,
            mut query,
        ) = system_state.get_mut(&mut app.world);
        
        my_build_system(commands, event_reader, query);
    }
}

Feedback Wanted

I'm both fairly new to Bevy and rust, so there might be obvious reasons why this isn't a good idea that I'm not seeing.

• Do you think this could work?
• If yes, what changes would be needed?
• If no, why?

[Nilirad]

I think the best way to run systems inside Plugin::build is by using one-shot systems (#4090).