fix queued events dispatched in stale state when anonymous transitions are pending (#542)

[PavelGuzenfeld]

Problem

When an action used back::process<E> to enqueue a new event, process_queued_events drained the entire process queue in a single while-loop pass. The outer event-processing loop never got to run anonymous (guard-only) transitions between consecutive queued-event dispatches.

Example: given a machine with

*state<sa> + event<e>[!g] / (++n; enqueue e{count-1})
 state<sa> + on_entry<_>  / (n = 0)          // reset on entry
 state<sa> [g]            = state<sb>         // anonymous: leave sa when n>0

the first event fires in sa and enqueues a second event. With the old code, the second event is dispatched immediately, still in sa, before the anonymous transition to sb runs. The action increments n again, guard !g is now false, and every subsequent queued event is silently dropped.

This is the root cause reported in #542. The same bug affects any state machine where the active state changes via an anonymous transition after an action enqueues further events.

Fix

Change the while-loop in process_queued_events to an if-block so that each call dispatches exactly one queued event and returns true if there was something to dispatch. The outer do { ... } while (process_queued_events(...)) loop already calls process_queued_events repeatedly (see the triple-nested do-while structure in process_event), so all queued events are still eventually drained—but now anonymous transitions and defer-queue drains run between each pair of consecutive queued events.

⚠️ Behaviour change

Previously all queued events were dispatched atomically before any anonymous transitions fired. After this fix, each queued event is followed by a full anonymous-transition + defer-drain cycle. State machines that implicitly relied on the old batch-drain semantics will observe different transition ordering. This is the minimal change required to make the semantics correct, but consumers should be aware.

Test

Regression test added in test/ft/actions_process.cpp (process_queue_anonymous_transitions_between_queued_events): a four-state cycling machine where each state's on-entry resets a counter used by an anonymous guard. Processing e{5} from the initial state enqueues five more events recursively; with the bug only two fire, with the fix all six fire.

Existing tests (including actions_process_n_defer) pass without modification.

Fixes #542.