ecs: ergonomic query.iter(), remove locks, add QuerySets

[cart]

Summary

• query.iter() is now a real iterator!

  // This means you can do this:
  for (a, b) in query.iter() { }
  
  // Instead of this:
  for (a, b) in &mut query.iter() {}
  
  // Or this:
  for (a, b) in query.iter().iter() {}
  
  // Good riddance!

• query.entity() is now "flat".

  // This means you can do this:
  if let Ok((a, b)) = query.entity(entity) {}
  
  // Instead of this:
  if let Ok(mut result) = query.entity(entity) {
    if let Some((a, b)) = result.get() { }
  }
  
  // Boilerplate be gone!

• All locks and safety checks removed from direct Query accesses. This means query.iter() and query.entity() are exactly as fast as their World counterparts (which became lock-less in the last bevy_ecs update). This is because ...
• Query safety is now enforced in the query system function signature. Querys are not allowed to conflict, by default. If you need conflicting Queries in your system, wrap them in the new QuerySet type. This provides lifetime safety that prevents illegal query accesses:

  // this system will now fail when constructing the schedule because `a` and `b` conflict
  fn system(a: Query<&mut A>, b: Query<(&mut A, &B)>) {
  }
  
  // you can use QuerySets to work around this safely
  fn system(set: QuerySet<(Query<&mut A>, Query<(&mut A, &B)>)>) {
    for a in set.q0_mut().iter_mut() {
      // the borrow checker will fail here because `set` is already borrowed mutably
      // this would have failed at runtime in previous bevy_ecs versions, but now we fail at compile time!  
      for (a, b) in set.q1_mut().iter_mut() {
      } 
    }
  }

• Systems can now run even more parallel-ly than they could before. Systems that have mutability conflicts on the same archetype can now still run in parallel provided the individual components don't have mutability conflicts
• query.par_iter() and query.par_iter_mut() were added to the top level Query type
• replaced the access() -> Option<Access>, borrow(), and release() methods on Fetch with a single, much simpler and flexible access() -> QueryAccess
• Impl ExactSizeIterator for QueryIter, but only when the Query can cheaply return an exact size without a full scan (uses the new UnfilteredFetch trait)
• Rewrote QueryIter to be much simpler. This results in much more stable and predictable optimizations. This should prevent certain permutations of systems (and sets of systems) from falling off the "fast/optimized path", as called out here: Establishing More Reliable Benchmarks #655 (comment)

[cart]

benchmark results:

(any omitted benchmarks from ecs_bench_suite had no significant changes)

The most interesting outcomes:

1. Retrieving individual query results in systems is crazy fast now. I included a comparison to legion to illustrate the benefits of the lock-less approach. Legion cannot validate SubWorld calls ahead of time, so it must validate each one. Bevy "pre-validates" query access, which means it can skip the safety checks for anything that immediately matches the query:
   • get_component/bevy: direct world access using world.get::<Component>(entity)
   • get_component/bevy_query: retrieving a component from Query<&mut Component> using query.entity(entity)
   • get_component/legion: direct world access using let entry = world.entry(entity); entry.get_component_mut::<A>()
   • get_component/legion_system: SubWorld access using let entry = world.entry(entity); entry.get_component_mut::<A>()
2. Some nice improvements to frag_iter results

[BoxyUwU]

The docs on ParallelExecutor need to be updated to talk about the parallelism change I think

[cart]

done!