Store mtime to the nanosecond so a same-second rewrite is re-hashed (closes #12)

scan recorded mtime in whole seconds, so a file rewritten in place at
the same size within the same second as its recorded mtime was classed
unchanged and kept its old hashes. The files table keeps mtime as whole
Unix seconds and gains mtime_nsec, the nanoseconds within that second.
scan holds the mtime as a time.Time and decides "newer" with After, so
any time a filesystem can record, one after 2262 included, compares in
the right order. The walk, a file given as an operand, and the content
phase's recheck all move over. PRAGMA user_version stays 1, per the
owner's ruling. README states what both columns hold.

Model: opus-5-5

scan.go

@@ -416,7 +416,7 @@ func (s *scanState) walkPhase(
 		old, ok := s.existing[ev.rec.path]
 
 		switch {
-		case !ok || old.size != ev.rec.size || mtimeAfter(ev.rec.mtime, old.mtime):
+		case !ok || old.size != ev.rec.size || ev.rec.mtime.After(old.mtime):
 			changed = append(changed, ev.rec)
 		case old.hashed:
 			delete(s.existing, ev.rec.path)
@@ -808,7 +808,7 @@ func unchangedFile(r scanRec) (fileRec, bool, error) {
 	}
 
 	if !fi.Mode().IsRegular() || fi.Size() != r.size ||
-		mtimeAfter(fi.ModTime(), r.mtime) {
+		fi.ModTime().After(r.mtime) {
 		return fileRec{}, false, nil
 	}
 
@@ -819,16 +819,6 @@ func unchangedFile(r scanRec) (fileRec, bool, error) {
 	}, true, nil
 }
 
-// mtimeAfter reports whether mtime a is later than mtime b.
-// Not a.After(b): time.Time wraps an mtime past year 292 billion; Unix() undoes it.
-func mtimeAfter(a, b time.Time) bool {
-	if a.Unix() != b.Unix() {
-		return a.Unix() > b.Unix()
-	}
-
-	return a.Nanosecond() > b.Nanosecond()
-}
-
 // underAnyRoot reports whether path is any of the roots or lies under
 // one of them.
 func underAnyRoot(path string, roots []string) bool {

scan_test.go

@@ -1446,30 +1446,12 @@ func TestSyncScanOperandSameSecondRewrite(t *testing.T) {
 	assertWholeFileHashed(t, db, a, rewritten)
 }
 
-// TestSyncScanRewriteAfter2262 runs assertLateRewriteRehashed with an
+// TestSyncScanRewriteAfter2262 rewrites a file in place at the same
-// mtime after 2262, a time too late to count in nanoseconds in an int64.
+// size and sets its mtime after 2262, a time too late to count in
+// nanoseconds in an int64: the next scan must still re-hash it.
 func TestSyncScanRewriteAfter2262(t *testing.T) {
 	t.Parallel()
 
-	assertLateRewriteRehashed(t, time.Date(2300, 1, 2, 3, 4, 5, 0, time.UTC))
-}
-
-// TestSyncScanRewritePastTimeLimit runs assertLateRewriteRehashed with an
-// mtime one second past the latest a time.Time holds without wrapping it
-// to a time far in the past.
-func TestSyncScanRewritePastTimeLimit(t *testing.T) {
-	t.Parallel()
-
-	assertLateRewriteRehashed(t, time.Unix(9223371974719179008, 0))
-}
-
-// assertLateRewriteRehashed scans a directory, rewrites a file in it in
-// place at the same size, sets its mtime to late, and fails unless the
-// next scan re-hashes the file. It skips where late does not fit the
-// platform's timespec or the filesystem does not store it.
-func assertLateRewriteRehashed(t *testing.T, late time.Time) {
-	t.Helper()
-
 	dir := t.TempDir()
 	db := openTestDB(t)
 	a := writeFile(t, dir, "a.bin", pattern(1, 500))
@@ -1482,11 +1464,12 @@ func assertLateRewriteRehashed(t *testing.T, late time.Time) {
 	rewritten := pattern(3, 500)
 	writeFile(t, dir, "a.bin", rewritten)
 
-	// os.Chtimes cannot set such a time: it converts through UnixNano.
+	// os.Chtimes cannot set this time: it converts through UnixNano.
+	late := time.Date(2300, 1, 2, 3, 4, 5, 0, time.UTC)
+
 	ts, err := unix.TimeToTimespec(late)
 	if err != nil {
-		t.Skipf("an mtime %d seconds after 1970 does not fit this platform's "+
+		t.Skipf("%v does not fit this platform's timespec: %v", late, err)
-			"timespec: %v", late.Unix(), err)
 	}
 
 	err = unix.UtimesNano(a, []unix.Timespec{ts, ts})
@@ -1499,9 +1482,9 @@ func assertLateRewriteRehashed(t *testing.T, late time.Time) {
 		t.Fatal(err)
 	}
 
-	if fi.ModTime().Unix() != late.Unix() {
+	if !fi.ModTime().Equal(late) {
-		t.Skipf("the filesystem stored the mtime as %d seconds after 1970, "+
+		t.Skipf("the filesystem stored mtime %v instead of %v",
-			"not %d", fi.ModTime().Unix(), late.Unix())
+			fi.ModTime().UTC(), late)
 	}
 
 	st := syncTree(t, db, dir)