docs: auto-sync documentation and rosetta examples

Author: github-actions[bot]

docs.zenc-lang.org/content/tour/08-memory-management.de.md

@@ -69,11 +69,29 @@ fn main() {
 ```
 
 #### RAII / Drop Trait
-Implementiere `Drop`, um automatische Aufräumlogik auszuführen.
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
 impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**Umhüllen eines RAII-Typs.** Wenn dein Struct ein Feld enthält, das bereits `Drop` implementiert (wie `Vec` oder `String`), kümmert sich der Compiler automatisch um die Bereinigung. Du musst kein `impl Drop` für das äußere Struct schreiben.
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**Beispiel:** `String` ist als `struct String { vec: Vec<char>; }` definiert -- es benötigt keine explizite `Drop`-Implementierung, da `Vec<char>` den gesamten Speicher verwaltet. `Set<T>` hingegen verwendet rohe `T*`-Zeiger und benötigt explizites `Drop`.
+{% end %}
+
+**Faustregel:**
+- Felder vom Typ `Vec<T>`, `String` oder andere RAII-Typen → automatisches Drop
+- Felder vom Typ `T*`, `malloc`-Zeiger oder Dateihandles → explizites Drop erforderlich

docs.zenc-lang.org/content/tour/08-memory-management.es.md

@@ -63,11 +63,29 @@ fn main() {
 ```
 
 #### RAII / Drop Trait
-Implementa `Drop` para ejecutar lógica de limpieza automáticamente.
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
-impl Drop for MiEstructura {
+impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**Envolver un tipo RAII.** Si tu struct contiene un campo que ya implementa `Drop` (como `Vec` o `String`), el compilador maneja la limpieza automáticamente. NO necesitas escribir `impl Drop` para el struct externo.
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**Ejemplo:** `String` se define como `struct String { vec: Vec<char>; }` — NO necesita una implementación explícita de `Drop` porque `Vec<char>` gestiona toda la memoria. `Set<T>` por otro lado usa punteros `T*` sin procesar y SÍ necesita `Drop` explícito.
+{% end %}
+
+**Regla general:**
+- Campos que son `Vec<T>`, `String` u otros tipos RAII → Drop automático
+- Campos que son `T*`, punteros `malloc` o manejadores de archivos → Drop explícito requerido

docs.zenc-lang.org/content/tour/08-memory-management.it.md

@@ -63,11 +63,29 @@ fn main() {
 ```
 
 #### RAII / Rilascio Tratti
-Implementa `Drop` per una logica di pulizia automatica.
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
-impl Drop for MioStruct {
+impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**Avvolgere un tipo RAII.** Se la tua struttura contiene un campo che implementa già `Drop` (come `Vec` o `String`), il compilatore gestisce automaticamente la pulizia. NON è necessario scrivere `impl Drop` per la struttura esterna.
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**Esempio:** `String` è definita come `struct String { vec: Vec<char>; }` -- NON necessita di un'implementazione esplicita di `Drop` perché `Vec<char>` gestisce tutta la memoria. `Set<T>` invece usa puntatori `T*` grezzi e necessita di `Drop` esplicito.
+{% end %}
+
+**Regola pratica:**
+- Campi che sono `Vec<T>`, `String` o altri tipi RAII → Drop automatico
+- Campi che sono `T*`, puntatori `malloc` o handle di file → Drop esplicito richiesto

docs.zenc-lang.org/content/tour/08-memory-management.md

@@ -67,11 +67,34 @@ fn main() {
 ```
 
 #### RAII / Drop Trait
-Implement `Drop` to run cleanup logic automatically.
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
 impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**Wrapping an RAII type.** If your struct contains a field that already implements
+`Drop` (like `Vec` or `String`), the compiler handles cleanup automatically.
+You do NOT need to write `impl Drop` for the outer struct.
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**Example:** `String` is defined as `struct String { vec: Vec<char>; }` — it
+does NOT need an explicit `Drop` implementation because `Vec<char>` handles
+all the memory. `Set<T>` on the other hand uses raw `T*` pointers and
+DOES need explicit `Drop`.
+{% end %}
+
+**Rule of thumb:**
+- Fields that are `Vec<T>`, `String`, or other RAII types → automatic Drop
+- Fields that are raw `T*`, `malloc`'d pointers, or file handles → explicit Drop required

docs.zenc-lang.org/content/tour/08-memory-management.pt.md

@@ -67,11 +67,29 @@ fn main() {
 ```
 
 #### RAII / Drop Trait
-Implementa `Drop` para executar lógica de limpeza automaticamente.
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
 impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**Encapsulando um tipo RAII.** Se seu struct contém um campo que já implementa `Drop` (como `Vec` ou `String`), o compilador cuida da limpeza automaticamente. Você NÃO precisa escrever `impl Drop` para o struct externo.
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**Exemplo:** `String` é definida como `struct String { vec: Vec<char>; }` — NÃO precisa de uma implementação explícita de `Drop` porque `Vec<char>` gerencia toda a memória. `Set<T>` por outro lado usa ponteiros `T*` brutos e PRECISA de `Drop` explícito.
+{% end %}
+
+**Regra prática:**
+- Campos que são `Vec<T>`, `String` ou outros tipos RAII → Drop automático
+- Campos que são `T*`, ponteiros `malloc` ou handles de arquivo → Drop explícito necessário

docs.zenc-lang.org/content/tour/08-memory-management.ru.md

@@ -63,11 +63,29 @@ fn main() {
 ```
 
 #### RAII / Трейт Drop
-Реализуйте `Drop` для автоматического запуска логики очистки.
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
 impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**Обёртка RAII-типа.** Если ваша структура содержит поле, которое уже реализует `Drop` (например, `Vec` или `String`), компилятор обрабатывает очистку автоматически. Вам НЕ нужно писать `impl Drop` для внешней структуры.
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**Пример:** `String` определён как `struct String { vec: Vec<char>; }` -- ему НЕ нужна явная реализация `Drop`, потому что `Vec<char>` управляет всей памятью. `Set<T>` напротив использует сырые указатели `T*` и ТРЕБУЕТ явного `Drop`.
+{% end %}
+
+**Правило:**
+- Поля `Vec<T>`, `String` или другие RAII-типы → автоматический Drop
+- Поля `T*`, `malloc`-указатели или файловые дескрипторы → требуется явный Drop

docs.zenc-lang.org/content/tour/08-memory-management.zh-cn.md

@@ -66,12 +66,30 @@ fn main() {
 }
 ```
 
-#### RAII / Drop Trait
-实现 `Drop` 以自动运行清理逻辑。
+#### RAII / Drop 特性
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
 impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**包装 RAII 类型。**如果结构体包含已经实现了 `Drop` 的字段（如 `Vec` 或 `String`），编译器会自动处理清理。你**不需要**为外部结构体编写 `impl Drop`。
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**示例：** `String` 定义为 `struct String { vec: Vec<char>; }` -- 它**不需要**显式的 `Drop` 实现，因为 `Vec<char>` 管理所有内存。而 `Set<T>` 使用原始 `T*` 指针，**需要**显式的 `Drop`。
+{% end %}
+
+**经验法则：**
+- `Vec<T>`、`String` 或其他 RAII 类型的字段 → 自动 Drop
+- `T*`、`malloc` 分配的指针或文件句柄 → 需要显式 Drop

docs.zenc-lang.org/content/tour/08-memory-management.zh-tw.md

@@ -66,12 +66,30 @@ fn main() {
 }
 ```
 
-#### RAII / Drop Trait
-實現 `Drop` 以自動運行清理邏輯。
+#### RAII / Drop 特性
+
+Implement `Drop` to run cleanup logic automatically when a value goes out of scope.
+
 ```zc
 impl Drop for MyStruct {
     fn drop(self) {
         self.free();
     }
 }
 ```
+
+**包裝 RAII 類型。**如果結構體包含已經實作了 `Drop` 的欄位（如 `Vec` 或 `String`），編譯器會自動處理清理。你**不需要**為外部結構體編寫 `impl Drop`。
+
+```zc
+struct MyVecWrapper {
+    inner: Vec<int>;  // Vec::drop() called automatically
+}
+```
+
+{% alert(type="note") %}
+**範例：** `String` 定義為 `struct String { vec: Vec<char>; }` -- 它**不需要**顯式的 `Drop` 實作，因為 `Vec<char>` 管理所有記憶體。而 `Set<T>` 使用原始 `T*` 指標，**需要**顯式的 `Drop`。
+{% end %}
+
+**經驗法則：**
+- `Vec<T>`、`String` 或其他 RAII 類型的欄位 → 自動 Drop
+- `T*`、`malloc` 分配的指標或檔案控制代碼 → 需要顯式 Drop