[application] Remove Event MMR

[patrick-ogrady]

We should just compute a root over the events at some height (using bmt) rather than storing an events root.

This change will cut ~50% off the commit flow at the end of a block (

battleware/execution/src/state_transition.rs

Lines 82 to 105 in 51db184

	// Apply events if this is the next block
	if height == events_height + 1 {
	events_start_op = events.op_count();
	for output in outputs.into_iter() {
	events.append(output).await.unwrap();
	}
	events
	.commit(Some(Output::Commit {
	height,
	start: events_start_op,
	}))
	.await
	.unwrap();
	}
	// Apply state once we've committed events (can't regenerate after state updated)
	state.apply(layer.commit()).await;
	state
	.commit(Some(Value::Commit {
	height,
	start: state_start_op,
	}))
	.await
	.unwrap();

), won't limit our ability to service event proofs (can still prove any subset of block events using this bmt), and will simplify recovery logic (don't need to worry about committing event before state).

If we want to retain a global event index for all items, we can store the last index value in the commit metadata (with height) and start event block indexing at that value. This would still allow us to offer an API that walks the event history without any meaningful overhead for the node.

[erayack]

I had a chance to review it, and here is the plan. Please let me know what you think.

1. Metadata Updates: Value::Commit will now expose state_start and next_event_index. Progress will switch from MMR-specific fields to BMT-friendly events_root, events_start_index, and events_count. The Output::Commit variant is being removed.
2. Execution Result Reshaping: The execute_state_transition function will derive the next global event index from Value::Commit. After execution, outputs will be partitioned, assigned global indices, and a BMT will be built for them. The StateTransitionResult will now carry BMT-related data (root, indices, count, raw events) and the raw event list.
3. Node Application Rework: The node application will cease using the keyless::Keyless MMR store. It will adapt to the new execute_state_transition signature, capture the returned events payload, and use BMT multi-proofs for verification, sending BMT commitment data and raw events to the aggregator.
4. Aggregator Data Flow Redesign: The aggregator will process BlockEvents (containing BMT root, start index, events, and proofs) instead of MMR proofs. It will persist new BMT fields in Progress and upload summaries with BMT root and events. Filtered updates will generate ad-hoc BMT multi-proofs from cached block events.
5. API Structure and Verification Revision: API structures (Summary, Events, FilteredEvents) will be redefined to consume BMT-based event bundles and fields. Verification logic (Summary::verify, etc.) will recompute/verify the BMT root from provided data.
6. Widespread Consumer Updates: All components that relied on MMR-backed events, including the client, simulator, Randotron, WASM, and execution mocks, will be updated to use the new BMT-based verification and data structures.
7. Code Cleanup: Ancillary code related to commonware_storage::adb::keyless and MMR-specific event partitions will be removed.