chore(i18n): finish translating code comments and scripts to English

Completes the English-only standardization for code, comments, scripts
and CI templates (UI/CLI-facing strings stay bilingual pt-BR/en,
untouched). Covers the remaining crates/, apps/gui/ui/ and
apps/gui/src-tauri/ comments, .gitea/ workflow and template comments,
.githooks/ hooks, and the scripts/ source comments for the files
already renamed in a prior commit (check.sh, generate-logo.py,
install-hooks.sh).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VAyr8d7HuAdUGB6aA5xmDD

crates/guara-core/src/fs/xfs.rs

@@ -1,7 +1,7 @@
-//! XFS (v4 e v5): mapa de espaço livre pela árvore de blocos livres de cada grupo de alocação e
-//! arquivos apagados. Ao liberar um inode, o XFS zera o modo e o tamanho mas não apaga a lista de
-//! extents que ficou dentro do inode; e a entrada de diretório liberada perde só os 4 primeiros
-//! bytes (o número do inode), preservando o nome. Juntamos as duas sobras.
+//! XFS (v4 and v5): free-space map from each allocation group's free-block B+tree and deleted
+//! file recovery. When freeing an inode, XFS zeroes mode and size if not fully wiped, leaving
+//! inline extent records in the inode fork; freed directory entries only overwrite the first
+//! 4 bytes of the 8-byte inode number, preserving the low 32 bits and the filename.
 
 use super::{make_found, merge_extents, Ctx, NewFound, VolumeScan};
 use crate::signatures;
@@ -88,7 +88,7 @@ impl<'a> Xfs<'a> {
         self.base + agno * self.agblocks * self.bs
     }
 
-    /// Endereço físico de um bloco "fsblock" (agno << agblklog | agbno).
+    /// Converts an XFS `fsblock` (`agno << agblklog | agbno`) to a physical byte offset.
     fn fsb_off(&self, fsb: u64) -> Option<u64> {
         let (agno, agbno) = (fsb >> self.agblklog, fsb & ((1 << self.agblklog) - 1));
         (agno < self.agcount && agbno < self.agblocks).then(|| self.ag_off(agno) + agbno * self.bs)
@@ -116,7 +116,7 @@ impl<'a> Xfs<'a> {
         }
     }
 
-    /// Extents de um inode com a lista no próprio inode (formato 2) ou em árvore (formato 3).
+    /// Reads extents from an inode data fork (format 2 inline extent list or format 3 B+tree).
     fn extents_of(&self, ino: &[u8], max_blocks: u64) -> Vec<(u64, u64, u64)> {
         let fmt = ino[5];
         let start = self.core_size(ino);
@@ -135,7 +135,7 @@ impl<'a> Xfs<'a> {
                 }
             }
             3 => {
-                // raiz da árvore de extents no inode: nível, nregistros, chaves e ponteiros
+                // B+tree root inside the inode fork: level, numrecs, keys, and block pointers
                 let level = be16(lit, 0) as usize;
                 let nrecs = be16(lit, 2) as usize;
                 let maxrecs = (lit.len() - 4) / 16;
@@ -180,7 +180,7 @@ impl<'a> Xfs<'a> {
     }
 }
 
-/// Registro de extent empacotado em 128 bits: flag(1) | início no arquivo(54) | bloco(52) | quantidade(21).
+/// Unpacks a 128-bit XFS extent record: `flag(1) | startoff(54) | startblock(52) | blockcount(21)`.
 fn unpack_extent(r: &[u8]) -> (u64, u64, u64) {
     let hi = u64::from_be_bytes(r[0..8].try_into().unwrap());
     let lo = u64::from_be_bytes(r[8..16].try_into().unwrap());
@@ -190,7 +190,7 @@ fn unpack_extent(r: &[u8]) -> (u64, u64, u64) {
     (startoff, startblock, count)
 }
 
-/// Percorre as folhas de uma árvore B+ curta, entregando cada registro de 16 (inobt) ou 8 (bnobt) bytes.
+/// Walks the leaves of an AG B+tree, yielding each 16-byte (`inobt`) or 8-byte (`bnobt`) record.
 fn walk_short_btree(
     x: &Xfs,
     agno: u64,
@@ -201,7 +201,7 @@ fn walk_short_btree(
     f: &mut dyn FnMut(&[u8]),
 ) {
     let mut cur = root;
-    // desce pela esquerda até a folha
+    // descend leftmost branch down to the leaf level
     for lvl in (1..levels).rev() {
         let Ok(b) = read_vec(x.src, x.ag_off(agno) + cur * x.bs, x.bs as usize) else {
             return;
@@ -241,10 +241,10 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
         return res;
     };
 
-    // Espaço livre por grupo e inodes livres.
+    // Collect free-space ranges and free inode records across all allocation groups.
     let mut free: Vec<Extent> = vec![];
-    let mut free_set: Vec<(u64, u64)> = vec![]; // (fsblock inicial, quantidade) para checar blocos
-    let mut chunks: Vec<(u64, u64, u64)> = vec![]; // (agno, startino, máscara livre)
+    let mut free_set: Vec<(u64, u64)> = vec![]; // (start_fsblock, block_count) for free-block checks
+    let mut chunks: Vec<(u64, u64, u64)> = vec![]; // (agno, startino, free_bitmask)
     for agno in 0..x.agcount {
         if (ctx.cancelled)() {
             return res;
@@ -278,10 +278,10 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
             .is_some_and(|&(s, c)| s <= fsb && s + c >= fsb + count)
     };
 
-    // Nomes: entradas de diretório liberadas (guardam o nome e os 4 bytes baixos do inode).
+    // Names: freed directory entries (preserve filename and low 32 bits of the inode number).
     let (live_dirs, stale_names) = collect_names(&x, ctx);
 
-    // Inodes livres com a lista de extents ainda dentro do inode.
+    // Free inodes that still contain leftover extent records in their data fork.
     let max_blocks = x.dblocks;
     let mut seen_first: HashSet<u64> = HashSet::new();
     for (agno, startino, mask) in &chunks {
@@ -290,7 +290,7 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
         }
         for i in 0..64u64 {
             if mask >> i & 1 == 0 {
-                continue; // em uso
+                continue; // allocated inode
             }
             let ino = (agno << (x.agblklog + x.inopblog)) | (startino + i);
             let Some(raw) = x.read_ino(ino) else { continue };
@@ -298,13 +298,13 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
             if mode != 0 && be32(&raw, 16) != 0 {
                 continue;
             }
-            // Só inodes que foram arquivos: o formato de extents continua gravado e há sobras.
+            // Check freed inodes that still have non-zero extent records in the data fork.
             if raw[5] != 2 {
                 continue;
             }
             let start = x.core_size(&raw);
             let lit = &raw[start..];
-            // lê registros plausíveis em sequência
+            // read consecutive plausible extent records
             let mut ext: Vec<(u64, u64, u64)> = vec![];
             let mut next_off = 0u64;
             for k in 0..lit.len() / 16 {
@@ -346,7 +346,7 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
             } else {
                 "blocos do arquivo já reaproveitados".to_string()
             };
-            // tamanho exato: tenta achar o fim real pelo conteúdo
+            // exact size was zeroed on deletion: refine size from file structure when possible
             let mut est = true;
             if let Some(h) = read_vec(ctx.src, extents[0].offset, 128)
                 .ok()
@@ -394,7 +394,7 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
     res
 }
 
-/// Percorre os diretórios vivos; devolve (caminho de cada diretório por inode, nome liberado por inode baixo).
+/// Walks live directories; returns `(dir_paths_by_inode, freed_names_by_low_inode_u32)`.
 fn collect_names(x: &Xfs, ctx: &Ctx) -> (HashMap<u64, String>, HashMap<u64, (u64, String)>) {
     let mut paths: HashMap<u64, String> = HashMap::new();
     let mut stale: HashMap<u64, (u64, String)> = HashMap::new();
@@ -414,7 +414,7 @@ fn collect_names(x: &Xfs, ctx: &Ctx) -> (HashMap<u64, String>, HashMap<u64, (u64
         let start = x.core_size(&raw);
         match raw[5] {
             1 => {
-                // pasta curta guardada no inode
+                // shortform directory stored inline inside the inode
                 let lit = &raw[start..];
                 let count = lit[0] as usize;
                 let i8 = lit[1] != 0;
@@ -443,7 +443,7 @@ fn collect_names(x: &Xfs, ctx: &Ctx) -> (HashMap<u64, String>, HashMap<u64, (u64
                 let ex = x.extents_of(&raw, 1 << 20);
                 let _ = size;
                 for (off, fsb, cnt) in ex {
-                    // blocos de dados de diretório ficam antes do offset de 32 GiB (depois vêm folhas e índice)
+                    // directory data blocks live below the 32 GiB logical offset (leaf/freeindex blocks live above)
                     if off * x.bs >= 32u64 << 30 {
                         continue;
                     }
@@ -479,7 +479,7 @@ fn parse_dir_block(
         _ => return,
     };
     let is_block = magic == b"XD2B" || magic == b"XDB3";
-    // em blocos únicos, o final tem a tabela de folhas
+    // single-block directory: trim the trailing leaf/tail table
     let end = if is_block {
         let cnt = be32(b, b.len() - 8) as usize;
         b.len().saturating_sub(8 + cnt * 8)
@@ -493,7 +493,7 @@ fn parse_dir_block(
             if len < 8 || p + len > end {
                 break;
             }
-            // entrada liberada: sobraram (inode baixo, nome); outras ainda podem estar dentro da região
+            // freed entry region: extract `(low_inode_u32, name)` and any subsequent unlinked entries inside the region
             scan_free_region(x, &b[p..p + len], dino, stale);
             p += len;
             continue;
@@ -517,7 +517,7 @@ fn parse_dir_block(
 }
 
 fn scan_free_region(x: &Xfs, r: &[u8], dir_ino: u64, stale: &mut HashMap<u64, (u64, String)>) {
-    // 1) a primeira entrada perdeu só os 4 primeiros bytes do número do inode
+    // 1) the first unlinked entry at the start of the free tag lost only the upper 4 bytes of its inode number
     let try_at = |p: usize, low: u64, stale: &mut HashMap<u64, (u64, String)>| -> Option<usize> {
         let nl = *r.get(p + 8)? as usize;
         let name = r.get(p + 9..p + 9 + nl)?;
@@ -532,7 +532,7 @@ fn scan_free_region(x: &Xfs, r: &[u8], dir_ino: u64, stale: &mut HashMap<u64, (u
     if r.len() >= 16 {
         let low = be32(r, 4) as u64;
         if let Some(sz) = try_at(0, low, stale) {
-            // entradas seguintes dentro da mesma região, com o inode inteiro
+            // subsequent coalesced entries inside the same free region still have their full 8-byte inode number
             let mut p = sz;
             while p + 16 <= r.len() {
                 let ino = be64(r, p);