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)