Cache filename for sorting in fill_todo (#181)

Alternative to #144.

This reduces the duration to glob `**/*.rs` in a rustc checkout on my PC
from ~1000ms to ~820ms:
```
Benchmark 1: ./local
  Time (mean ± σ):     822.0 ms ±  11.2 ms    [User: 272.5 ms, System: 549.2 ms]
  Range (min … max):   811.8 ms … 849.6 ms    10 runs
 
Benchmark 2: ./upstream
  Time (mean ± σ):      1.019 s ±  0.006 s    [User: 0.468 s, System: 0.551 s]
  Range (min … max):    1.005 s …  1.026 s    10 runs
 
Summary
  ./local ran
    1.24 ± 0.02 times faster than ./upstream
```

Author: Kobzol

src/lib.rs

@@ -73,6 +73,7 @@ doctest!("../README.md");
 use std::cmp;
 use std::cmp::Ordering;
 use std::error::Error;
+use std::ffi::OsString;
 use std::fmt;
 use std::fs;
 use std::fs::DirEntry;
@@ -945,24 +946,29 @@ fn fill_todo(
             let dirs = fs::read_dir(path).and_then(|d| {
                 d.map(|e| {
                     e.map(|e| {
-                        let path = if curdir {
-                            PathBuf::from(e.path().file_name().unwrap())
+                        // We sort by filename a few lines below. However, it is actually quite
+                        // expensive to extract the filename from PathBuf. Since we already know the
+                        // filename from `DirEntry` here, we store it proactively (we still
+                        // have to heap allocate it).
+                        // Then we use this cached filename for sorting, and further on work only
+                        // with the full path.
+                        let (path, filename) = if curdir {
+                            (PathBuf::from(e.path().file_name().unwrap()), e.file_name())
                         } else {
-                            e.path()
+                            (e.path(), e.file_name())
                         };
-                        PathWrapper::from_dir_entry(path, e)
+                        (PathWrapper::from_dir_entry(path, e), filename)
                     })
                 })
-                .collect::<Result<Vec<_>, _>>()
+                .collect::<Result<Vec<(PathWrapper, OsString)>, _>>()
             });
             match dirs {
                 Ok(mut children) => {
                     if options.require_literal_leading_dot {
-                        children
-                            .retain(|x| !x.file_name().unwrap().to_str().unwrap().starts_with('.'));
+                        children.retain(|x| !x.1.to_str().unwrap().starts_with('.'));
                     }
-                    children.sort_by(|p1, p2| p2.file_name().cmp(&p1.file_name()));
-                    todo.extend(children.into_iter().map(|x| Ok((x, idx))));
+                    children.sort_by(|p1, p2| p2.1.cmp(&p1.1));
+                    todo.extend(children.into_iter().map(|x| Ok((x.0, idx))));
 
                     // Matching the special directory entries . and .. that
                     // refer to the current and parent directory respectively