Add observable OnCollisionStart and OnCollisionEnd events

[Jondolf]

Objective

Closes #361.
Closes #481.

A common user request is to allow listening to collision events for specific entities, with an API where you don't need to check e.g. which entity is the player and which entity is an enemy like you might need to do when using CollisionStarted and CollisionEnded. The typical Bevy API for per-entity events like this is observers.

On the surface, this is a straightforward addition. However, there have historically been some challenges and open questions:

1. We don't want to trigger collision events for every contact. Doing so would mean that we get one buffered event and two observable events (one for each entity) per started/ended contact pair, which could add up to a decent amount of overhead.
2. Observable events shouldn't store two entities like CollisionStarted and CollisionEnded do. The Trigger already stores the observed entity.
3. Should we trigger the observers immediately in the narrow phase, which could be slightly more efficient, or should we defer events until after the solver so that contact impulses have been computed?

Now that #683 made collision events opt-in via the CollisionEventsEnabled component, I consider (1) to be solved. We can only trigger the event for entities with that component. The other two are more just a matter of how we want to design this, but I would assert that (2) we should just have separate types for buffered and observable events, and (3) we should trigger the events after the solver, because having access to contact impulses is valuable, even if it has a small extra cost.

Solution

Add OnCollisionStart and OnCollisionEnd events that are triggered when an entity starts or stops colliding with another entity. The naming was chosen to be distinct enough from CollisionStarted and CollisionEnded, while reflecting Bevy's observer event names such as OnAdd or Pointer<Move> (present tense verb).

The events are triggered after the solver by iterating through the buffered events and checking which entities have CollisionEventsEnabled. System-local buffers and exclusive world access are used to try and minimize overhead and unnecessary allocations.

Usage of the events might look like this:

use avian3d::prelude::*;
use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct PressurePlate;

fn setup_pressure_plates(mut commands: Commands) {
    commands.spawn((
        PressurePlate,
        Collider::cuboid(1.0, 0.1, 1.0),
        Sensor,
        // Enable collision events for this entity.
        CollisionEventsEnabled,
    ))
    .observe(|trigger: Trigger<OnCollisionStart>, player_query: Query<&Player>| {
        let pressure_plate = trigger.entity();
        if player_query.contains(trigger.0) {
            println!("Player {trigger.0} stepped on pressure plate {pressure_plate}");
        }
    });
}

The system that triggers the events runs in a CollisionEventSystems system set in a new PhysicsStepSet::Finalize system set right before PhysicsStepSet::Last.