sync: stat each file once per scan, not twice (#66)

`scan_folder` called `child.metadata()` twice for every file it keeps.
`DirEntry::metadata` is a fresh `lstat` on each call, so the second one
bought nothing:

    let (mtime_secs, mtime_nanos) = mtime_of(&child);   // lstat
    let disk = child.metadata().ok();                   // lstat again

`mtime_of_metadata` already existed and takes a `&Metadata`, so the
single-call shape was in the file the whole time. `mtime_of` was a
`DirEntry` wrapper around it that forced the extra call. It has no other
caller and is removed.

MEASURED, AND IT IS A SMALL WIN. Do not read it as a large one.

The watched tree on Silber holds 17,063 files. One `lstat` pass over all
of them costs 36 ms wall on this machine, warm, best of three. The bus
entry ran 12.2 scans a minute over a 419 second window, so the redundant
call costs about 0.43 s of CPU a minute, or 0.72 percent of one core.

Treat 0.72 percent as an UPPER bound. I measured the syscall from Python,
whose per-call interpreter overhead is included in the 2.08 us per file
and would not be present in this loop.

WHAT THIS DOES NOT FIX, SO NOBODY READS IT AS THE ANSWER. The dominant
idle cost on Silber is that one changed file triggers a full walk of the
whole tree, about 21 times a minute. Halving the stats per file makes the
walk cheaper. It does not stop the walk from happening.

Agent: Silber.fabric

Author: myobie

src/sync/engine.rs

@@ -1342,8 +1342,16 @@ fn scan_folder(
             if !entry.includes(&norm) {
                 continue;
             }
-            let (mtime_secs, mtime_nanos) = mtime_of(&child);
+            // One stat per file, not two. `DirEntry::metadata` is a fresh
+            // lstat on every call, and this loop used to call it twice: once
+            // inside `mtime_of` and again on the next line. `mtime_of_metadata`
+            // already takes the result, so the single-call shape was in the
+            // file the whole time.
             let disk = child.metadata().ok();
+            let (mtime_secs, mtime_nanos) = disk
+                .as_ref()
+                .map(mtime_of_metadata)
+                .unwrap_or((0, 0));
             let size = disk.as_ref().map(|meta| meta.len()).unwrap_or(u64::MAX);
             let executable = disk.as_ref().is_some_and(is_executable);
             // Reuse the recorded hash when size and both mtime components are
@@ -1832,13 +1840,6 @@ fn mtime_of_metadata(meta: &std::fs::Metadata) -> (i64, u32) {
     }
 }
 
-fn mtime_of(entry: &std::fs::DirEntry) -> (i64, u32) {
-    let Ok(meta) = entry.metadata() else {
-        return (0, 0);
-    };
-    mtime_of_metadata(&meta)
-}
-
 /// Resolve the tombstone sweep window from `FABRIC_TOMBSTONE_SWEEP_DAYS`.
 ///
 /// Unset means the sweep is OFF. That is deliberate: forgetting a tombstone is