Consider combining `SystemParam::validate_params` and `get_params`

[alice-i-cecile]

@cart says:

The redundant work in validate_param, which is done immediately before get_param never felt great to me. This isn't a problem exclusive to Res/ResMut, but it is certainly present.

I think doing validation as part of get_param is more defensible from a performance perspective.

I think it is worth doing some benchmarks where we skip validation (as-in, across all SystemParams), just to see what price we're paying here.

IMO the best way to restructure this would be to have get_param return a Result<Self::Item, SystemParamValidationError>, effectively combining the signature with validate_param.

[alice-i-cecile]

Notes on the validate_params path:

1. SystemParam::validate_param needs to be removed, while SystemParam::get_param needs to return a Result
2. When converting to a system, SystemParam::validate_param is called by System::validate_param_unsafe
3. System::validate_param_unsafe is then wrapped by the safe System::validate_param, which is a single-threaded equivalent
4. When running system single-threaded, System::run_without_applying_deferred calls System::validate_param_unsafe, before calling System::run_unsafe.
5. Inside of the parallel executor, System::validate_param_unsafe is called inside of ExecutorState::should_run, and is evaluated at the same time as we check for run conditions.
6. The error handler is called inside of that should_run step, and can warn/crash/whatever mid-validation.
7. should_run is then called inside of spawn_system_tasks, and systems which are skipped (via validation or run criteria) are skipped, removing them from the schedule for that pass.
8. If the system is not skipped, a task is spun up and we run the system!

However, there is an oddity around run_unsafe:

1. ExecutorState::spawn_system_task calls a wrapped variant of System::run_unsafe, called __rust_begin_short_backtrace::run_unsafe.
2. This returns a Result<(), RunSystemError>, which can store either Skipped or Failed. Are we double-validating??
3. Checking the implementation of System for FunctionSystem, we find that it does not actually perform validation in there. It calls SystemParam::get_param on the SystemState stored inside however, which would be very convenient for our plans.
4. The final value returned by System::run_unsafe is produced by calling IntoResult::into_result on the value produced by calling the stored func inside of our FunctionSystem.
5. This is either always Ok in some form, or bubbles the error up from a system which returns Result<T, BevyError>.
6. This conversion process takes any returned Err branch and turns it into a failure.

Okay, so conclusions:

1. Untangling this is very complex. I'm not sure we should be trying to do this before a real code quality pass on our parallel executor, per Increase structure for schedule executors to reduce boilerplate and ensure consistency #18453. Maybe we should though: this would simplify things and make that work easier.
2. Whether or not we should do this is unclear. Being able to save spinning up a task is a huge performance gain currently, and lumping this into the same path as run conditions fundamentally makes sense to me.
3. On the other hand, if most systems pass validation most of the time, this would be a substantial benefit. Saving on look-ups will improve performance, particularly for simple systems that don't do a ton of work.
4. Combining validation + running into a single atomic step should give us significant robustness and simplicity improvements, in addition to any hypothetical performance improvements.

If we do choose to do this, we need to:

1. Merge SystemParam::validate_params with SystemParam::get_params, making the latter return a Result and deleting the former.
2. Early return in the various implementations of System::run_unsafe.
3. Add another variant RunSystemError, distinguishing "validation failed" from "system ran but returned an error". Reusing RunSystemError::Failed for both cases is messy.
4. Completely delete System::validate_param and System::validate_param_unsafe. Validation now occurs when a system is run, not before.