fix(cloud-files): Pin/Unpin tatsaechlich wirksam machen + CLI-Logging

set_pin_state hatte drei Probleme:
- FILE_READ_ATTRIBUTES: CfSetPinState braucht WRITE_ATTRIBUTES
- Kein OPEN_REPARSE_POINT: das Oeffnen selbst hat evtl. die
  Hydration getriggert, bevor wir unpinnen konnten
- Kein CfDehydratePlaceholder: Pin-Wechsel auf UNPINNED aendert
  nur das Flag, der Disk-Space wird nicht freigegeben

Jetzt:
- WRITE_ATTRIBUTES + OPEN_REPARSE_POINT beim Handle-Oeffnen
- Bei Unpin zusaetzlich CfDehydratePlaceholder, damit "Speicher
  freigeben" auch wirklich Platz freiraeumt
- Ergebnis + Fehler werden nach <parent>\.minicloud-cloudfiles.log
  geschrieben, damit wir sehen was passiert

handle_cli_shortcuts loggt nun nach %LOCALAPPDATA%\MiniCloud Sync\
cli.log, weil Explorer die stdout/stderr eines gestarteten Prozesses
verwirft. Ohne das Log kann man die vom Kontextmenue gestarteten
Aktionen nicht debuggen.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

clients/desktop/src-tauri/src/cloud_files/windows.rs

@@ -509,20 +509,24 @@ fn create_placeholder(
 
 pub fn set_pin_state(file: &Path, pinned: bool) -> Result<(), String> {
     use windows::Win32::Storage::FileSystem::{
-        CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_READ_ATTRIBUTES,
-        FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
+        CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,
+        FILE_WRITE_ATTRIBUTES, FILE_READ_ATTRIBUTES,
+        FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_SHARE_DELETE, OPEN_EXISTING,
     };
 
     let path_wide = U16CString::from_str(file.to_string_lossy().as_ref())
         .map_err(|e| e.to_string())?;
+    // CfSetPinState / CfDehydratePlaceholder brauchen WRITE_ATTRIBUTES.
+    // OPEN_REPARSE_POINT verhindert, dass das Oeffnen selbst eine
+    // Hydration ausloest (sonst waere Unpin bedeutungslos).
     let handle = unsafe {
         CreateFileW(
             PCWSTR(path_wide.as_ptr()),
-            FILE_READ_ATTRIBUTES.0,
-            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            (FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES).0,
+            FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
             None,
             OPEN_EXISTING,
-            FILE_FLAG_BACKUP_SEMANTICS,
+            FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
             None,
         )
     }
@@ -533,12 +537,50 @@ pub fn set_pin_state(file: &Path, pinned: bool) -> Result<(), String> {
     } else {
         CF::CF_PIN_STATE_UNPINNED
     };
-    let res = unsafe {
+    let set_res = unsafe {
         CF::CfSetPinState(handle, state, CF::CF_SET_PIN_FLAG_NONE, None)
     };
+
+    // "Speicher freigeben" (unpin): sofort dehydrieren, damit der Platz
+    // wirklich frei wird. CfSetPinState allein aendert nur den Zustand.
+    // Der Rueckgabewert wird geloggt aber nicht hart als Fehler gewertet,
+    // weil die Datei evtl. schon dehydriert ist.
+    let dehydrate_err = if !pinned && set_res.is_ok() {
+        let r = unsafe {
+            CF::CfDehydratePlaceholder(
+                handle,
+                0,
+                -1,
+                CF::CF_DEHYDRATE_FLAG_NONE,
+                None,
+            )
+        };
+        r.err().map(|e| format!("{:?}", e))
+    } else {
+        None
+    };
+
     unsafe {
         let _ = windows::Win32::Foundation::CloseHandle(handle);
     }
-    res.map_err(|e| format!("CfSetPinState: {e}"))?;
+
+    // Log-Verzeichnis ist der Mount-Ordner oder dessen Parent
+    let log_dir = file
+        .ancestors()
+        .find(|p| p.parent().is_some())
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| file.to_path_buf());
+    log_msg(
+        &log_dir,
+        &format!(
+            "set_pin_state file={} pinned={} result={:?} dehydrate_err={:?}",
+            file.display(),
+            pinned,
+            set_res,
+            dehydrate_err
+        ),
+    );
+
+    set_res.map_err(|e| format!("CfSetPinState: {e}"))?;
     Ok(())
 }