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-entities/src/domain/auth/session_lock.rs

@@ -1,14 +1,32 @@
 //! PID-file based advisory lock preventing two processes from operating on
 //! the same session directory concurrently.
+//!
+//! # Flow
+//!
+//! [`SessionLock::new`] creates a handle → [`SessionLock::try_lock`] attempts
+//! atomic `O_CREAT|O_EXCL` creation. If the lock file already exists, the
+//! owning PID is checked via `kill(pid, 0)` + `/proc/<pid>/exe` verification.
+//! Stale locks are overwritten atomically (temp-file + rename + fsync).
+//! On [`Drop`], the lock file is removed automatically.
+//!
+//! # Components
+//!
+//! - `SessionLock` — RAII guard wrapping a lock file path and PID
+//! - `try_lock` — three-phase atomic acquire with stale-lock recovery
+//! - `unlock` / `Drop` — explicit and implicit release
+//! - `is_alive` — liveness check via `libc::kill` + `/proc` verification
 use std::fs;
 use std::io::Write;
 use std::path::{Path, PathBuf};
+use tracing;
 
 /// A PID-file lock (`<session_dir>/.lock`) tied to the current process,
 /// auto-removed on drop.
 #[derive(Debug)]
 pub struct SessionLock {
+    /// Path to the `.lock` file inside the session directory.
     path: PathBuf,
+    /// Process ID that holds (or will hold) this lock.
     pid: u32,
 }
 
@@ -47,9 +65,11 @@ impl SessionLock {
             Ok(mut file) => {
                 write!(file, "{}", self.pid)?;
                 file.sync_all()?;
+                tracing::debug!(path = %self.path.display(), pid = self.pid, "session lock acquired");
                 return Ok(true);
             }
             Err(ref e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
+                tracing::debug!(path = %self.path.display(), "session lock already exists, checking staleness");
                 // Lock file exists — check if it's stale.
             }
             Err(e) => return Err(e),
@@ -59,8 +79,10 @@ impl SessionLock {
         let content = fs::read_to_string(&self.path).unwrap_or_default();
         if let Ok(pid) = content.trim().parse::<u32>() {
             if Self::is_alive(pid) {
+                tracing::warn!(stale = pid, path = %self.path.display(), "session lock held by live process");
                 return Ok(false);
             }
+            tracing::debug!(stale = pid, "stale lock detected, overwriting");
         }
 
         // Phase 3: stale lock — overwrite it atomically (best-effort).