feat: add MergeEventQueues node (#133)

This PR adds a `MergeEventQueues` node that concatenates two event
queues into one. This is needed when you have multiple event sources
(e.g. a `FireEventNode` and a `ClipNode`'s event output) that need to
feed into a single event queue input like the FSM's driver.

### What it does

- **`MergeEventQueues`** (`Merge Events`): Takes two `EventQueue` inputs
and concatenates them into a single output queue.

### Discussion: is explicit merging the right approach?

In the current architecture, event queues are explicit data pins that
users must manually wire through the graph. This means combining events
from multiple sources requires an explicit merge node.

Esoterica takes a fundamentally different approach: events are appended
into a **single shared buffer** during graph evaluation. Each node
returns a `SampledEventRange` (start/end index pair) describing its
slice. Blend nodes call `BlendEventRanges()` to combine children's
ranges and scale weights by the blend factor. Events propagate
implicitly alongside poses — users never wire event connections
manually.

The Esoterica approach is more elegant (no manual wiring, events
automatically weighted by blend factors), but would require significant
architectural changes to adopt here. This node is a pragmatic stopgap
for the current pin-based event architecture.

I may be missing prior discussion or design notes on this — apologies if
this has already been considered and the current explicit approach was a
deliberate choice. But I wanted to flag the question: is there interest
in moving toward implicit event propagation (Esoterica-style shared
buffer), or is the explicit pin-based approach the intended long-term
design? Happy to hear if there's context I'm not aware of. Either way,
this node solves an immediate wiring problem I ran into.

### AI Disclosure

I used AI (Claude Code) to research how Esoterica handles event
propagation and to generate the node implementation.

Author: baszalmstra

crates/bevy_animation_graph_builtin_nodes/src/event_queue/merge_event_queues.rs

@@ -0,0 +1,43 @@
+use bevy::prelude::*;
+use bevy_animation_graph_core::{
+    animation_node::{NodeLike, ReflectNodeLike},
+    context::{new_context::NodeContext, spec_context::SpecContext},
+    edge_data::DataSpec,
+    errors::GraphError,
+};
+
+/// Merges two event queues into one.
+#[derive(Reflect, Clone, Debug, Default)]
+#[reflect(Default, NodeLike)]
+#[type_path = "bevy_animation_graph::builtin_nodes"]
+pub struct MergeEventQueues;
+
+impl MergeEventQueues {
+    pub const IN_A: &'static str = "in_a";
+    pub const IN_B: &'static str = "in_b";
+    pub const OUTPUT: &'static str = "out";
+
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl NodeLike for MergeEventQueues {
+    fn display_name(&self) -> String {
+        "Merge Events".into()
+    }
+
+    fn update(&self, mut ctx: NodeContext) -> Result<(), GraphError> {
+        let a = ctx.data_back(Self::IN_A)?.into_event_queue()?;
+        let b = ctx.data_back(Self::IN_B)?.into_event_queue()?;
+        ctx.set_data_fwd(Self::OUTPUT, a.concat(b));
+        Ok(())
+    }
+
+    fn spec(&self, mut ctx: SpecContext) -> Result<(), GraphError> {
+        ctx.add_input_data(Self::IN_A, DataSpec::EventQueue)
+            .add_input_data(Self::IN_B, DataSpec::EventQueue)
+            .add_output_data(Self::OUTPUT, DataSpec::EventQueue);
+        Ok(())
+    }
+}

crates/bevy_animation_graph_builtin_nodes/src/event_queue/mod.rs

@@ -1,2 +1,3 @@
 pub mod fire_event;
 pub mod map_events;
+pub mod merge_event_queues;

crates/bevy_animation_graph_builtin_nodes/src/lib.rs

@@ -6,7 +6,9 @@ use crate::{
     chain_node::ChainNode,
     clip_node::ClipNode,
     dummy_node::DummyNode,
-    event_queue::{fire_event::FireEventNode, map_events::MapEventsNode},
+    event_queue::{
+        fire_event::FireEventNode, map_events::MapEventsNode, merge_event_queues::MergeEventQueues,
+    },
     f32::{
         abs_f32::AbsF32, add_f32::AddF32, clamp_f32::ClampF32, compare_f32::CompareF32,
         div_f32::DivF32, mul_f32::MulF32, sub_f32::SubF32,
@@ -86,6 +88,7 @@ impl BuiltinNodesPlugin {
             // event queue
             .register_type::<FireEventNode>()
             .register_type::<MapEventsNode>()
+            .register_type::<MergeEventQueues>()
             // ragdoll
             .register_type::<ConstRagdollConfig>();
     }

release-content/release-notes/merge_event_queues.md

@@ -0,0 +1,7 @@
+---
+title: Merge Event Queues Node
+authors: ["@baszalmstra"]
+pull_requests: [133]
+---
+
+A new `MergeEventQueues` node has been added that concatenates two event queues into one. This is useful when multiple event sources (e.g. a `FireEventNode` and a `ClipNode`'s event output) need to feed into a single event queue input like the FSM's driver.