Store and compare file mtimes to the nanosecond (closes #226)

The files table held mtime in whole seconds and the scanner compared
whole seconds. A file rewritten with its size unchanged and a new mtime
in the same second as the indexed one was treated as unchanged, and
every later snapshot restored the old content. A new mtime_nsec column
now holds the nanoseconds within the second that mtime holds, and the
scanner compares the full mtime.

A local index created before this change lacks the column and is
rebuilt with `vaultik database delete` and a full backup. A snapshot
made before it cannot be restored by this version.

Model: opus-5-5

internal/database/files_test.go

@@ -252,6 +252,115 @@ func TestFileRepositorySymlink(t *testing.T) {
 	}
 }
 
+// An mtime after 2262 or before 1678 does not fit in int64 nanoseconds
+// since the epoch, and must still come back from the database unchanged.
+func TestFileRepositoryMTimeOutsideInt64NanosecondRange(t *testing.T) {
+	t.Parallel()
+
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := database.NewFileRepository(db)
+
+	mtimes := []time.Time{
+		time.Date(2300, time.January, 1, 0, 0, 0, 123456789, time.UTC),
+		time.Date(1601, time.January, 1, 0, 0, 0, 987654321, time.UTC),
+	}
+
+	for _, mtime := range mtimes {
+		created := &database.File{
+			Path:  types.FilePath("/created-" + mtime.Format(time.RFC3339Nano)),
+			MTime: mtime,
+		}
+
+		err := repo.Create(ctx, nil, created)
+		if err != nil {
+			t.Fatalf("failed to create file: %v", err)
+		}
+
+		batched := &database.File{
+			ID:    types.NewFileID(),
+			Path:  types.FilePath("/batched-" + mtime.Format(time.RFC3339Nano)),
+			MTime: mtime,
+		}
+
+		err = repo.CreateBatch(ctx, nil, []*database.File{batched})
+		if err != nil {
+			t.Fatalf("failed to batch create file: %v", err)
+		}
+
+		for _, path := range []types.FilePath{created.Path, batched.Path} {
+			retrieved, err := repo.GetByPath(ctx, path.String())
+			if err != nil {
+				t.Fatalf("failed to get file: %v", err)
+			}
+
+			if !retrieved.MTime.Equal(mtime) {
+				t.Errorf("%s: mtime got %v, want %v",
+					path, retrieved.MTime, mtime)
+			}
+		}
+	}
+}
+
+// A file already in the index and rewritten within the same second must get
+// its new nanoseconds stored, through both Create and CreateBatch.
+func TestFileRepositoryUpsertMTimeInSameSecond(t *testing.T) {
+	t.Parallel()
+
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := database.NewFileRepository(db)
+
+	indexed := time.Date(2026, time.October, 7, 12, 0, 0, 100000000, time.UTC)
+	rewritten := indexed.Add(800 * time.Millisecond)
+
+	tests := []struct {
+		name   string
+		upsert func(file *database.File) error
+	}{
+		{"Create", func(file *database.File) error {
+			return repo.Create(ctx, nil, file)
+		}},
+		{"CreateBatch", func(file *database.File) error {
+			return repo.CreateBatch(ctx, nil, []*database.File{file})
+		}},
+	}
+
+	for _, tt := range tests {
+		file := &database.File{
+			ID:    types.NewFileID(),
+			Path:  types.FilePath("/" + tt.name),
+			MTime: indexed,
+		}
+
+		err := tt.upsert(file)
+		if err != nil {
+			t.Fatalf("%s: failed to create file: %v", tt.name, err)
+		}
+
+		file.MTime = rewritten
+
+		err = tt.upsert(file)
+		if err != nil {
+			t.Fatalf("%s: failed to update file: %v", tt.name, err)
+		}
+
+		retrieved, err := repo.GetByPath(ctx, file.Path.String())
+		if err != nil {
+			t.Fatalf("%s: failed to get file: %v", tt.name, err)
+		}
+
+		if !retrieved.MTime.Equal(rewritten) {
+			t.Errorf("%s: mtime got %v, want %v",
+				tt.name, retrieved.MTime, rewritten)
+		}
+	}
+}
+
 func TestFileRepositoryTransaction(t *testing.T) {
 	t.Parallel()