I had the same ideas but used comprehensions to add the edges and get the valid paths. First time this year I’ve used :digraph and didn’t have to refactor it away when I realized it wasn’t the right setup.

defmodule Day10 do
  @test """
  89010123
  78121874
  87430965
  96549874
  45678903
  32019012
  01329801
  10456732
  """
  @real File.read!(__DIR__ <> "/input.txt")

  @neighbors [{0, 1}, {0, -1}, {1, 0}, {-1, 0}]

  defp input(:test), do: @test
  defp input(:real), do: @real
  defp input(_), do: raise("Please use :test or :real as the mode to run.")

  defp parse(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.with_index()
    |> Enum.reduce({:digraph.new(), %{}}, fn {line, i}, {map, indexed} ->
      line
      |> String.graphemes()
      |> Enum.map(&String.to_integer/1)
      |> Enum.with_index()
      |> Enum.reduce({map, indexed}, fn {n, j}, {mp, ndxd} ->
        :digraph.add_vertex(mp, {i, j}, n)
        {mp, Map.update(ndxd, n, [{i, j}], fn curr -> [{i, j} | curr] end)}
      end)
    end)
  end

  defp add_edges(graph) do
    for {i, j} <- :digraph.vertices(graph),
        {k, l} <- :digraph.vertices(graph) -- [{i, j}],
        {di, dj} <- @neighbors,
        {i + di, j + dj} == {k, l} do
      {{i, j}, n} = :digraph.vertex(graph, {i, j})
      {{k, l}, m} = :digraph.vertex(graph, {k, l})

      case n - m do
        1 -> :digraph.add_edge(graph, {k, l}, {i, j})
        -1 -> :digraph.add_edge(graph, {i, j}, {k, l})
        _ -> false
      end
    end

    graph
  end

  def run(mode) do
    {map, indexed} =
      mode
      |> input()
      |> parse()

    add_edges(map)

    part_1({map, indexed}) |> IO.inspect(label: :part_1)
    part_2({map, indexed}) |> IO.inspect(label: :part_2)
  end

  defp part_1({map, indexed}) do
    trailheads = indexed[0]
    targets = indexed[9]

    good_trails =
      for th <- trailheads, te <- targets, :digraph.get_path(map, th, te), reduce: %{} do
        acc -> Map.update(acc, th, [te], fn curr -> [te | curr] end)
      end

    score(good_trails)
  end

  defp score(trails) do
    trails
    |> Enum.map(fn {_, nines} -> Enum.count(nines) end)
    |> Enum.sum()
  end

  defp part_2({map, indexed}) do
    for hd <- indexed[0],
        one <- indexed[1],
        :digraph.get_path(map, hd, one),
        two <- indexed[2],
        :digraph.get_path(map, one, two),
        three <- indexed[3],
        :digraph.get_path(map, two, three),
        four <- indexed[4],
        :digraph.get_path(map, three, four),
        five <- indexed[5],
        :digraph.get_path(map, four, five),
        six <- indexed[6],
        :digraph.get_path(map, five, six),
        seven <- indexed[7],
        :digraph.get_path(map, six, seven),
        eight <- indexed[8],
        :digraph.get_path(map, seven, eight),
        nine <- indexed[9],
        :digraph.get_path(map, eight, nine), reduce: 0 do
      acc -> acc + 1
    end
  end
end

Day10.run(:real)