refactor(delta): simplify after multi-agent review pass

Net: 77 fewer lines, same behavior, same tests green.

Code reuse
----------
* `Reducer.add_to_coll/5`, `remove_from_coll/4`, `replace_in_coll/5` —
  collapse 14 near-duplicate Add/Remove/Alter/Rename apply_op clauses
  into uniform one-liners. Each helper accepts a thunk for the error
  message so inspect-heavy strings only build on the failure path.
* `MigrationGenerator.snapshot_filename?/2` and
  `dev_snapshot_filename?/1` — single source of truth for the
  `YYYYMMDDHHMMSS[_dev].json` convention. Previously defined inline
  in 5 places (2× squash, 1× migrate_snapshots, 2× migration_generator).
* `ash_postgres.squash_snapshots.ex apply_squash(..., :delta)` — drop
  the `maybe_hydrate_context/2` helper. `Reducer.apply_op(CreateTable)`
  already sets table/schema/multitenancy/repo/create_table_options, so
  the hand-hydration was both redundant and less complete than what
  the Reducer does.
* `Codec.decode_atom/1` — subsumes the identical
  `decode_optional_atom/1`.

Quality / efficiency
--------------------
* `Reducer`: drop the dead `state_empty?/1` final-override pass on
  `load_reduced_state/2`. Inline `empty?` writes already track
  correctness for every consumer of the returned state
  (`pkey_operations/4`).
* `Reducer.list_delta_files/2`: replace the 3-syscall
  `File.exists?`/`File.dir?`/`File.ls!` dance with a single
  `File.ls/1` pattern match. Also closes the TOCTOU gap.
* `ash_postgres.migrate_snapshots.ex find_legacy_directories/1`:
  return pre-classified `{dir, all_files, legacy_files}` tuples so
  `migrate_directory/5` doesn't re-read every file via `v2?/1`. Each
  file is now read exactly once during discovery.
* `migration_generator.ex move_rename_snapshots/3`: drop the
  `File.exists?(old_dir)` + `File.exists?(dst)` guards in favor of a
  single `File.ls/1`. Rename detection guarantees `new_dir` is empty,
  so the per-file guard was a defensive no-op.

Author: barnabasJ

lib/migration_generator/migration_generator.ex

@@ -201,6 +201,28 @@ defmodule AshPostgres.MigrationGenerator do
     end
   end
 
+  @snapshot_name_regex ~r/^\d{14}\.json$/
+  @dev_snapshot_name_regex ~r/^\d{14}_dev\.json$/
+
+  @doc false
+  # Does `name` (a basename, not a full path) match the snapshot file
+  # convention `YYYYMMDDHHMMSS.json`? If `include_dev?` is true, also matches
+  # the `*_dev.json` variant.
+  def snapshot_filename?(name, include_dev? \\ false)
+
+  def snapshot_filename?(name, false),
+    do: String.match?(name, @snapshot_name_regex)
+
+  def snapshot_filename?(name, true),
+    do:
+      String.match?(name, @snapshot_name_regex) or
+        String.match?(name, @dev_snapshot_name_regex)
+
+  @doc false
+  # Does `name` (a basename, not a full path) match a *_dev.json snapshot?
+  def dev_snapshot_filename?(name),
+    do: String.match?(name, @dev_snapshot_name_regex)
+
   defp snapshot_path(%{snapshot_path: snapshot_path}, _) when not is_nil(snapshot_path),
     do: snapshot_path
 
@@ -3252,10 +3274,7 @@ defmodule AshPostgres.MigrationGenerator do
     if File.exists?(snapshot_path) do
       snapshot_path
       |> File.ls!()
-      |> Enum.filter(
-        &(String.match?(&1, ~r/^\d{14}\.json$/) or
-            (opts.dev and String.match?(&1, ~r/^\d{14}\_dev.json$/)))
-      )
+      |> Enum.filter(&snapshot_filename?(&1, opts.dev))
       |> case do
         [] ->
           get_old_snapshot(folder, snapshot)
@@ -3306,11 +3325,9 @@ defmodule AshPostgres.MigrationGenerator do
 
     if File.exists?(snapshot_dir) do
       snapshot_files =
-        File.ls!(snapshot_dir)
-        |> Enum.filter(
-          &(String.match?(&1, ~r/^\d{14}\.json$/) or
-              (opts.dev and String.match?(&1, ~r/^\d{14}\_dev\.json$/)))
-        )
+        snapshot_dir
+        |> File.ls!()
+        |> Enum.filter(&snapshot_filename?(&1, opts.dev))
 
       case snapshot_files do
         [] ->
@@ -3683,27 +3700,22 @@ defmodule AshPostgres.MigrationGenerator do
             multitenancy: snap.multitenancy
           }
 
-          old_folder = get_snapshot_folder(old_snapshot, opts)
-          new_folder = get_snapshot_folder(new_snapshot, opts)
-          old_dir = get_snapshot_path(old_snapshot, old_folder)
-          new_dir = get_snapshot_path(new_snapshot, new_folder)
-
-          if File.exists?(old_dir) do
-            File.mkdir_p!(new_dir)
-
-            old_dir
-            |> File.ls!()
-            |> Enum.each(fn file ->
-              src = Path.join(old_dir, file)
-              dst = Path.join(new_dir, file)
-
-              # Skip if destination already exists — should not happen given
-              # rename detection only fires when the new dir is empty, but be
-              # defensive to avoid clobbering.
-              if !File.exists?(dst) do
-                File.rename!(src, dst)
-              end
-            end)
+          old_dir = get_snapshot_path(old_snapshot, get_snapshot_folder(old_snapshot, opts))
+          new_dir = get_snapshot_path(new_snapshot, get_snapshot_folder(new_snapshot, opts))
+
+          # Single File.ls — if old_dir is missing/unreadable we treat it as
+          # "nothing to move". Rename detection guarantees new_dir is empty,
+          # so no defensive per-file existence check is needed.
+          case File.ls(old_dir) do
+            {:ok, files} ->
+              File.mkdir_p!(new_dir)
+
+              Enum.each(files, fn file ->
+                File.rename!(Path.join(old_dir, file), Path.join(new_dir, file))
+              end)
+
+            {:error, _} ->
+              :ok
           end
         end)
       end

lib/migration_generator/operation/codec.ex

@@ -935,15 +935,12 @@ defmodule AshPostgres.MigrationGenerator.Operation.Codec do
 
   def decode_multitenancy(mt) do
     %{
-      strategy: mt |> Map.get(:strategy) |> decode_optional_atom(),
-      attribute: mt |> Map.get(:attribute) |> decode_optional_atom(),
+      strategy: mt |> Map.get(:strategy) |> decode_atom(),
+      attribute: mt |> Map.get(:attribute) |> decode_atom(),
       global: Map.get(mt, :global)
     }
   end
 
-  defp decode_optional_atom(nil), do: nil
-  defp decode_optional_atom(value), do: maybe_to_atom(value)
-
   defp decode_atom(nil), do: nil
   defp decode_atom(value), do: maybe_to_atom(value)