Walk an operand below .zfs or a symlink on its own (closes #142)

An operand under another was dropped as covered by it even when a
directory between them was named .zfs or was a symlink. The walk of
the outer operand enters neither, so the files under the inner operand
went unscanned and their records were deleted. walkReaches now reports
such an operand as not reached, so pruneRoots keeps it and walks it on
its own. README lists both cases with the others.

Judgement call: the new constant zfsDirName replaces the .zfs literal
in operandWarning and subdirJob too, because goconst rejects a third
copy.

Model: opus-5-5

scan_test.go

@@ -1672,6 +1672,81 @@ func TestSyncScanOverlappingRoots(t *testing.T) {
 	}
 }
 
+// TestScanWalksOperandInZFSDirectory checks that an operand inside a
+// directory named .zfs below another operand is walked on its own,
+// since the walk of the other operand does not enter .zfs. The file
+// under it is recorded, and a second scan keeps the record.
+func TestScanWalksOperandInZFSDirectory(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	f := writeFile(t, dir, "pool/.zfs/snapshot/daily/f", pattern(1, 10))
+	daily := filepath.Dir(f)
+
+	syncTree(t, db, dir, daily)
+	recordByPath(t, dbRecords(t, db), f)
+
+	syncTree(t, db, dir, daily)
+	recordByPath(t, dbRecords(t, db), f)
+}
+
+// TestScanWalksOperandBehindSymlink checks that an operand reached
+// through a symlinked directory below another operand is walked on its
+// own, since the walk of the other operand does not follow the symlink.
+// The file under it is recorded, and a second scan keeps the record.
+func TestScanWalksOperandBehindSymlink(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	target := t.TempDir()
+	db := openTestDB(t)
+	writeFile(t, target, "sub/f", pattern(1, 10))
+
+	link := filepath.Join(dir, "link")
+
+	err := os.Symlink(target, link)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sub := filepath.Join(link, "sub")
+	f := filepath.Join(sub, "f")
+
+	syncTree(t, db, dir, sub)
+	recordByPath(t, dbRecords(t, db), f)
+
+	syncTree(t, db, dir, sub)
+	recordByPath(t, dbRecords(t, db), f)
+}
+
+// TestScanDropsOperandReachedBehindSymlink checks that an operand under
+// another one is still dropped when both lie behind the same symlinked
+// directory: the walk of the other operand starts past the symlink and
+// reaches it, so the file under it is walked once.
+func TestScanDropsOperandReachedBehindSymlink(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	target := t.TempDir()
+	db := openTestDB(t)
+	writeFile(t, target, "sub/deeper/f", pattern(1, 10))
+
+	link := filepath.Join(dir, "link")
+
+	err := os.Symlink(target, link)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sub := filepath.Join(link, "sub")
+
+	st := syncTree(t, db, sub, filepath.Join(sub, "deeper"))
+	if st != (scanStats{walked: 1, added: 1}) {
+		t.Fatalf("stats = %+v, want 1 walked and added", st)
+	}
+}
+
 // TestScanHashesUniqueSize checks that a file whose size no other file
 // shares is hashed like every other file.
 func TestScanHashesUniqueSize(t *testing.T) {
@@ -2085,6 +2160,16 @@ func TestPruneRoots(t *testing.T) {
 		t.Fatalf("pruneRoots with %s not persistent = %q, want %q",
 			pqRoot, got, want)
 	}
+
+	// Nor does it enter a directory named .zfs, so /p/.zfs/s is kept. The
+	// walk of /p/.zfs/s reaches /p/.zfs/s/t, which is dropped.
+	got = pruneRoots([]string{"/p", "/p/.zfs/s", "/p/.zfs/s/t"}, false,
+		walkRules{}, device)
+
+	want = []string{"/p", "/p/.zfs/s"}
+	if !slices.Equal(got, want) {
+		t.Fatalf("pruneRoots with .zfs = %q, want %q", got, want)
+	}
 }
 
 func TestReportsNeverTouchFilesystem(t *testing.T) {