Please address the comments from this code review:

## Individual Comments

### Comment 1
<location> `internal/testpaths.go:44` </location>
<code_context>
 func WorkspaceTempDir(t testing.TB) string {
 	t.Helper()
-	tmpRoot := TestdataPath(".tmp")
+	tmpRoot := TestdataPath("../../.tmp")
 	err := os.Mkdir(tmpRoot, os.ModePerm)
 	if err != nil && !errors.Is(err, os.ErrExist) {
</code_context>

<issue_to_address>
**question (testing):** Changing the temp directory location may affect test isolation and cleanup.

Please verify that using a higher-level temp directory does not cause test interference, file residue, or permission problems, particularly in CI.
</issue_to_address>

### Comment 2
<location> `snaggle.go:181` </location>
<code_context>
+			return nil
+		}
+
+		switch {
+		case options.recursive:
+			return filepath.WalkDir(path, snagit)
</code_context>

<issue_to_address>
**issue (complexity):** Consider refactoring to use a single WalkDir call with fs.SkipDir to unify directory traversal and error handling.

You can collapse both branches into a single WalkDir call by using fs.SkipDir to prevent descending when not in recursive mode. This removes the manual ReadDir loop and the duplicated error‐handling logic:

```go
func Snaggle(path string, root string, opts ...Option) error {
    // … setup options, binDir, libDir …

    stat, err := os.Stat(path)
    if err != nil {
        return err
    }

    // if it’s just a file, we handle it directly
    if !stat.IsDir() {
        return snaggle(path, binDir, libDir, options)
    }

    // directory traversal for both recursive & non-recursive
    base := path
    return filepath.WalkDir(base, func(p string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }

        // skip subdirs if not in recursive mode
        if d.IsDir() && p != base && !options.recursive {
            return fs.SkipDir
        }
        // ignore all dirs
        if d.IsDir() {
            return nil
        }

        // process file
        err = snaggle(p, binDir, libDir, options)
        var badelf *debug_elf.FormatError
        if errors.As(err, &badelf) {
            // not an ELF, keep going
            return nil
        }
        return err
    })
}
```

What changed:

- Always use a single WalkDir
- Skip descending into subdirectories when !options.recursive
- Only one copy of the “snaggle + FormatError” logic instead of two branches
</issue_to_address>