feat(physics): add rigid-body rotation tracking (entity-based)

Addresses erematorg#145 (partial - entity backend only)

**SCOPE**: Entity-based rigid body rotation for non-continuum objects
(cameras, UI elements, large non-deformable bodies). Continuum matter
will use MPM (Material Point Method) when implemented.

**Added:**
- MomentOfInertia component (rigid body inertia)
- AppliedTorque component (torque application)
- integrate_torques system (τ = I·α integration)
- RotationalWorkEvent (feeds energy ledger)
- Helper functions: calculate_angular_momentum, calculate_rotational_kinetic_energy
- ForcesDiagnostics now tracks angular momentum + rotational KE
- Tests for all rotational physics formulas

**Architecture:**
- Entity backend: Uses components (MomentOfInertia, AppliedTorque)
- MPM backend (future): Will compute L = Σ(r × m·v) from particles
- Both backends feed same energy ledger for unified conservation

**TODO (MPM):**
- MPM particle-based angular momentum computation
- MPM rotational work tracking from grid interactions
- Aggregate diagnostics across both backends

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: M1thieu

crates/energy/src/conservation.rs

@@ -1,5 +1,5 @@
 use bevy::prelude::*;
-use forces::prelude::WorkDoneEvent;
+use forces::prelude::{RotationalWorkEvent, WorkDoneEvent};
 
 /// Enum representing different types of energy
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component, Reflect)]
@@ -297,6 +297,34 @@ pub fn track_work_from_forces(
     }
 }
 
+/// System to track rotational work done by torques and record in energy balance
+pub fn track_rotational_work_from_torques(
+    mut work_events: MessageReader<RotationalWorkEvent>,
+    mut query: Query<&mut EnergyBalance>,
+    time: Res<Time>,
+) {
+    for event in work_events.read() {
+        if let Ok(mut ledger) = query.get_mut(event.entity) {
+            // Same logic as linear work: positive work = energy input, negative = output
+            let (transaction_type, source, destination) = if event.work > 0.0 {
+                (TransactionType::Input, None, Some(event.entity))
+            } else {
+                (TransactionType::Output, Some(event.entity), None)
+            };
+
+            ledger.record_transaction(EnergyTransaction {
+                transaction_type,
+                amount: event.work.abs(),
+                source,
+                destination,
+                timestamp: time.elapsed_secs(),
+                transfer_rate: event.work.abs() / time.delta_secs().max(f32::EPSILON),
+                duration: time.delta_secs(),
+            });
+        }
+    }
+}
+
 /// Plugin to manage energy conservation systems
 pub struct EnergyConservationPlugin;
 
@@ -319,7 +347,8 @@ impl Plugin for EnergyConservationPlugin {
                 (
                     initialize_energy_balance,
                     ApplyDeferred,
-                    track_work_from_forces.after(forces::PhysicsSet::ApplyForces),
+                    (track_work_from_forces, track_rotational_work_from_torques)
+                        .after(forces::PhysicsSet::ApplyForces),
                 )
                     .chain(),
             );

crates/forces/src/core/mod.rs

@@ -15,10 +15,12 @@ pub mod prelude {
 
     // Re-export from newton_laws module
     pub use crate::core::newton_laws::{
-        AppliedForce, Distance, ForceImpulse, ForcesDiagnostics, ForcesDiagnosticsPlugin,
-        IntegratorKind, Mass, NewtonLawsPlugin, Norm, PairedForce, PairedForceInteraction,
-        Velocity, WorkDoneEvent, calculate_kinetic_energy, calculate_momentum,
-        integrate_newton_second_law, integrate_positions_symplectic_euler,
+        AppliedForce, AppliedTorque, Distance, ForceImpulse, ForcesDiagnostics,
+        ForcesDiagnosticsPlugin, IntegratorKind, Mass, MomentOfInertia, NewtonLawsPlugin, Norm,
+        PairedForce, PairedForceInteraction, RotationalWorkEvent, Velocity, WorkDoneEvent,
+        calculate_angular_momentum, calculate_kinetic_energy, calculate_momentum,
+        calculate_rotational_kinetic_energy, calculate_torque_from_force,
+        integrate_newton_second_law, integrate_positions_symplectic_euler, integrate_torques,
         update_forces_diagnostics,
     };
 }