docs: tambah doc comment, logging, dan inline comments di semua 255 file

Meliputi:
- File-level //! doc comment: tujuan file, alur kerja, komponen utama
- Function-level /// doc comment: apa, parameter, return, flow, edge cases
- Struct/enum/trait /// doc comment: peran, field docs
- Tracing logging (tracing::info!/debug!/trace!/warn!/error!) di setiap fungsi
- Inline comments untuk variable dan branching logic penting
- Seluruh 8 crates di workspace: zesdex-backend, zesdex-cms, zesdex-entities,
  zesdex-iam, zesdex-infra, zesdex-ipc, zesdex-middleware, zesdex-utils
- Build: 0 errors, 242/242 tests passed

crates/zesdex-backend/src/app/runtime/event_loop/mod.rs

@@ -1,9 +1,15 @@
 //! Adaptive poll-rate event loop: polls faster for IDLE_THRESHOLD_MS
 //! after any activity, then slows down to conserve CPU.
+//!
+//! Flow: `mark_active()` sets a fast-poll deadline; `poll_interval()`
+//! checks if the deadline is still in the future and returns either
+//! `FAST_POLL_MS` (8 ms) or `SLOW_POLL_MS` (100 ms). `is_idle()` reports
+//! whether the deadline has expired.
 use std::collections::VecDeque;
 use std::time::{Duration, Instant};
 
 use crate::app::state::runtime::TurnEvent;
+use tracing;
 
 const FAST_POLL_MS: u64 = 8;
 const SLOW_POLL_MS: u64 = 100;
@@ -40,9 +46,17 @@ impl EventLoop {
 
     /// Mark the current time as the last activity and arm the fast-poll
     /// window for the next `IDLE_THRESHOLD_MS`.
+    ///
+    /// Called by the event loop whenever a TurnEvent arrives, keeping the
+    /// UI responsive during bursts of activity.
     pub fn mark_active(&mut self) {
         self.last_activity = Instant::now();
-        self.fast_poll_until = Some(Instant::now() + Duration::from_millis(IDLE_THRESHOLD_MS));
+        let deadline = Duration::from_millis(IDLE_THRESHOLD_MS);
+        self.fast_poll_until = Some(Instant::now() + deadline);
+        tracing::debug!(
+            "[event-loop] marked active — fast-poll armed for next {}ms",
+            IDLE_THRESHOLD_MS,
+        );
     }
 
     /// Return `true` if the app has been idle for more than `IDLE_THRESHOLD_MS`.
@@ -52,11 +66,24 @@ impl EventLoop {
 
     /// Drain all pending `TurnEvent`s from the shared mutex queue.
     ///
+    /// Flow: acquire the mutex lock → drain the VecDeque into a Vec → release.
+    /// Returns an empty Vec if the lock is poisoned.
+    ///
     /// Return: a `Vec` of all events that were in the queue (may be empty).
     pub fn drain_events(
         events: &std::sync::Mutex<VecDeque<TurnEvent>>,
     ) -> Vec<TurnEvent> {
-        events.lock().map(|mut q| q.drain(..).collect()).unwrap_or_default()
+        let drained: Vec<TurnEvent> = events
+            .lock()
+            .map(|mut q| q.drain(..).collect())
+            .unwrap_or_default();
+        if !drained.is_empty() {
+            tracing::debug!(
+                "[event-loop] drained {} event(s)",
+                drained.len(),
+            );
+        }
+        drained
     }
 }