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/partition.rs

@@ -1,5 +1,5 @@
-//! Tabelas de partição (MBR/GPT), detecção de sistemas de arquivos,
-//! volumes cifrados e busca de partições perdidas.
+//! Partition tables (MBR/GPT), filesystem and encrypted volume detection,
+//! and lost-partition scanning across unallocated gaps.
 
 use crate::source::{read_vec, Source};
 use crate::types::{DiskLayout, FsKind, Gap, PartInfo};
@@ -7,7 +7,7 @@ use crate::types::{DiskLayout, FsKind, Gap, PartInfo};
 const SECTOR: u64 = 512;
 const MIN_GAP: u64 = 1024 * 1024;
 
-/// Identifica o sistema de arquivos que começa em `start` e (se possível) seu tamanho.
+/// Identifies the filesystem or container starting at `start` and its byte size when known.
 pub fn detect_fs(src: &dyn Source, start: u64) -> Option<(FsKind, Option<u64>)> {
     let b = read_vec(src, start, 4096).ok()?;
     if b.len() < 1100 {
@@ -16,7 +16,7 @@ pub fn detect_fs(src: &dyn Source, start: u64) -> Option<(FsKind, Option<u64>)>
     if let Some(r) = detect_fs_in(&b) {
         return Some(r);
     }
-    // Assinaturas mais adiante no volume: Btrfs (64 KiB) e RAID mdadm 1.2 (4 KiB).
+    // Signatures located further into the volume: Btrfs (64 KiB) and mdadm 1.2 RAID (4 KiB).
     if let Ok(h) = read_vec(src, start + 0x10000, 0x100) {
         if h.len() >= 0x80 && &h[0x40..0x48] == b"_BHRfS_M" {
             return Some((
@@ -33,7 +33,7 @@ pub fn detect_fs(src: &dyn Source, start: u64) -> Option<(FsKind, Option<u64>)>
     None
 }
 
-/// Mesma detecção sobre um buffer que começa no setor candidato (>= 1100 bytes).
+/// Runs volume signature detection on a buffer starting at the candidate sector (>= 1100 bytes).
 pub fn detect_fs_in(b: &[u8]) -> Option<(FsKind, Option<u64>)> {
     if b.len() < 1100 {
         return None;
@@ -133,8 +133,8 @@ fn detect_fat(b: &[u8]) -> Option<(FsKind, Option<u64>)> {
     let root_secs = (root_entries * 32).div_ceil(bps);
     let data = total.saturating_sub(reserved + nfats * fatsz + root_secs);
     let clusters = data / spc;
-    // O layout do BPB manda: raiz fixa zerada + FAT de 32 bits = FAT32, mesmo com poucos
-    // clusters (mkfs.vfat -F 32 em mídias pequenas gera isso e o Linux monta).
+    // BPB structure takes precedence: zero root-entry count + 32-bit FAT size = FAT32 even on
+    // small cluster counts (`mkfs.vfat -F 32` on small images produces this and Linux mounts it).
     let is32 = root_entries == 0 && fat16 == 0 && fat32 != 0;
     let kind = if is32 {
         FsKind::Fat32
@@ -146,7 +146,7 @@ fn detect_fat(b: &[u8]) -> Option<(FsKind, Option<u64>)> {
     Some((kind, Some(total * bps)))
 }
 
-/// Lê o rótulo (label) do volume quando disponível de forma simples.
+/// Reads the volume label when directly accessible in the superblock/boot sector.
 fn fat_label(b: &[u8], kind: FsKind) -> Option<String> {
     let off = if kind == FsKind::Fat32 { 71 } else { 43 };
     let s = String::from_utf8_lossy(b.get(off..off + 11)?)
@@ -155,9 +155,9 @@ fn fat_label(b: &[u8], kind: FsKind) -> Option<String> {
     (!s.is_empty() && s != "NO NAME").then_some(s)
 }
 
-// ----------------------------------------------------------------- tabelas
+// ----------------------------------------------------------------- partition tables
 
-/// Analisa o disco. `search_lost` varre lacunas atrás de volumes perdidos (lento em discos grandes).
+/// Inspects disk layout. `search_lost` scans unpartitioned gaps for lost volumes.
 pub fn analyze(src: &dyn Source, search_lost: bool) -> DiskLayout {
     let size = src.size();
     let mut layout = DiskLayout {
@@ -174,7 +174,7 @@ pub fn analyze(src: &dyn Source, search_lost: bool) -> DiskLayout {
         layout.table = "gpt".into();
         parts = g;
     } else if has_mbr {
-        // Pode ser MBR de verdade ou um setor de boot de volume sem tabela (superfloppy).
+        // Sector 0 may be either a partitioned MBR or a partitionless VBR ("superfloppy").
         let looks_boot = detect_fs_in(&read_vec(src, 0, 4096).unwrap_or_default()).is_some();
         if !looks_boot {
             let mp = read_mbr(src, &sector0, size);
@@ -197,7 +197,7 @@ pub fn analyze(src: &dyn Source, search_lost: bool) -> DiskLayout {
         }
     }
 
-    // Volume sem tabela de partições (pendrive "superfloppy" ou partição crua).
+    // Unpartitioned volume ("superfloppy" USB drive or single-partition image).
     if parts.is_empty() {
         if let Some((fs, len)) = detect_fs(src, 0) {
             parts.push(PartInfo {
@@ -217,12 +217,12 @@ pub fn analyze(src: &dyn Source, search_lost: bool) -> DiskLayout {
     parts.sort_by_key(|p| p.start);
     layout.gaps = compute_gaps(&parts, size);
 
-    // Partições perdidas: procurar assinaturas de volumes nas lacunas.
+    // Lost partitions: scan unallocated gaps for volume signatures.
     let mut lost = Vec::new();
     if search_lost {
         lost = find_lost(src, &layout.gaps, &parts);
         if parts.is_empty() && layout.table == "none" {
-            // Disco sem tabela nem volume no início: procurar no disco todo.
+            // No partition table or volume at sector 0: scan the entire disk for lost volumes.
             lost = find_lost(
                 src,
                 &[Gap {
@@ -304,7 +304,7 @@ fn read_mbr(src: &dyn Source, s0: &[u8], size: u64) -> Vec<PartInfo> {
             continue;
         }
         if ty == 0xEE {
-            continue; // MBR protetor de GPT
+            continue; // GPT protective MBR
         }
         if matches!(ty, 0x05 | 0x0F | 0x85) {
             ext_base = Some(lba * SECTOR);
@@ -365,7 +365,7 @@ fn part(index: usize, start: u64, len: u64, table_type: Option<String>) -> PartI
 }
 
 fn read_gpt(src: &dyn Source, size: u64) -> Option<Vec<PartInfo>> {
-    // Tenta o cabeçalho primário (LBA 1) e depois o de backup (último setor).
+    // Try the primary GPT header (LBA 1) first, falling back to the backup header (last LBA).
     let hdr = read_vec(src, SECTOR, 512)
         .ok()
         .filter(|h| h.len() == 512 && &h[0..8] == b"EFI PART")
@@ -383,7 +383,7 @@ fn read_gpt(src: &dyn Source, size: u64) -> Option<Vec<PartInfo>> {
     }
     let mut tbl = read_vec(src, table_lba * SECTOR, n * esz).ok()?;
     if tbl.len() < n * esz {
-        // Cabeçalho de backup aponta para a tabela de backup; se falhar, desiste.
+        // Backup GPT header points to the backup partition array; abort if both fail.
         tbl.resize(n * esz, 0);
     }
     let mut out = vec![];
@@ -418,7 +418,7 @@ fn read_gpt(src: &dyn Source, size: u64) -> Option<Vec<PartInfo>> {
 }
 
 fn gpt_type_name(guid: &[u8]) -> &'static str {
-    // GUIDs em formato de disco (mixed-endian).
+    // Known partition type GUIDs in on-disk mixed-endian byte order.
     match guid {
         [0x28, 0x73, 0x2A, 0xC1, 0x1F, 0xF8, 0xD2, 0x11, 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B] => {
             "EFI System"
@@ -445,7 +445,7 @@ fn gpt_type_name(guid: &[u8]) -> &'static str {
     }
 }
 
-/// Procura volumes (por assinatura) dentro de lacunas, em limites de setor.
+/// Scans unallocated byte gaps on sector boundaries for lost filesystem/volume headers.
 fn find_lost(src: &dyn Source, gaps: &[Gap], known: &[PartInfo]) -> Vec<PartInfo> {
     const CHUNK: u64 = 4 * 1024 * 1024;
     let mut found: Vec<PartInfo> = vec![];
@@ -468,7 +468,7 @@ fn find_lost(src: &dyn Source, gaps: &[Gap], known: &[PartInfo]) -> Vec<PartInfo
                 if abs >= skip_until {
                     let s = &buf[off as usize..];
                     if s.len() >= 1100 {
-                        // Filtro rápido: só chama a detecção completa se algum magic casa.
+                        // Fast pre-filter: only run full detection when a known magic byte sequence matches.
                         let quick = &s[3..11] == b"NTFS    "
                             || &s[3..11] == b"EXFAT   "
                             || &s[3..11] == b"-FVE-FS-"
@@ -477,13 +477,13 @@ fn find_lost(src: &dyn Source, gaps: &[Gap], known: &[PartInfo]) -> Vec<PartInfo
                             || (s[1080] == 0x53 && s[1081] == 0xEF);
                         if quick {
                             if let Some((fs, len)) = detect_fs_in(s) {
-                                // ext: o superbloco está a 1024 bytes do início do volume,
-                                // por isso o candidato ext é o setor atual (início do volume).
+                                // ext2/3/4: the superblock sits 1024 bytes into the volume,
+                                // so `off` (1024 bytes before the magic) is the candidate volume start.
                                 let len = len.unwrap_or(0);
                                 let ok = len >= 64 * 1024
                                     && abs + len <= src.size() + 1024 * 1024
                                     && !overlaps(known, abs, len);
-                                // Evita falso positivo de FAT em setor de boot MBR genérico.
+                                // Avoid false-positive FAT detection on generic MBR boot code.
                                 if ok && (fs != FsKind::Fat12 || len >= 512 * 1024) {
                                     let mut p =
                                         part(0, abs, len, Some("encontrada por varredura".into()));