I used a bit of metaprogramming to define the line processor that worked on binaries:

defp process_line(line) do
  process_line(line, _stack = [])
end

for <<open, close>> <- ["[]", "()", "{}", "<>"] do
  defp process_line(<<unquote(close), rest::bytes>>, [unquote(close) | stack]) do
    process_line(rest, stack)
  end

  defp process_line(<<unquote(open), rest::bytes>>, stack) do
    process_line(rest, [unquote(close) | stack])
  end
end

defp process_line(<<>>, []), do: :valid
defp process_line(<<>>, stack), do: {:incomplete, stack}
defp process_line(<<char, _rest::bytes>>, _stack), do: {:corrupted, char}

Full solution

Today’s problem seemed like a good match for Elixir.

defmodule AdventOfCode.Day10 do
  @chunks %{
    "(" => ")",
    "[" => "]",
    "{" => "}",
    "<" => ">"
  }

  def part1(input) do
    input
    |> parse_input()
    |> Enum.map(&eval_line/1)
    |> Enum.filter(&(elem(&1, 0) == :error))
    |> Enum.map(fn {_, v} -> v end)
    |> Enum.sum()
  end

  def part2(input) do
    results =
      input
      |> parse_input()
      |> Enum.map(&eval_line/1)
      |> Enum.filter(&(elem(&1, 0) == :ok))
      |> Enum.map(fn {_, v} -> v end)
      |> Enum.sort()

    middle = results |> length() |> div(2)
    Enum.at(results, middle)
  end

  def eval_line(line, open \\ [])

  def eval_line([head | tail], open) when head in ["(", "[", "{", "<"] do
    eval_line(tail, [head | open])
  end

  def eval_line([head | tail], [open_head | open_tail]) do
    if head == @chunks[open_head] do
      eval_line(tail, open_tail)
    else
      {:error, score_error(head)}
    end
  end

  def eval_line(_, open) do
    score =
      Enum.reduce(open, 0, fn char, acc ->
        acc * 5 + score_ac(@chunks[char])
      end)

    {:ok, score}
  end

  def score_error(")"), do: 3
  def score_error("]"), do: 57
  def score_error("}"), do: 1197
  def score_error(">"), do: 25137

  def score_ac(")"), do: 1
  def score_ac("]"), do: 2
  def score_ac("}"), do: 3
  def score_ac(">"), do: 4

  def parse_input(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&String.codepoints/1)
  end
end

I think it is equivalent except that my implementation for part2 needs to be updated to score openers instead of closers (since stack contains openers for incomplete lines). I rerun the tests with these two changes and they passed.

As for your original question,

Any reason it is better to match on insertion into the stack rather than on popping off the stack?

I don’t think I had any particular reason, at the moment it just made sense to add closers to the stack.

I think today’s puzzle was the one I enjoyed the most.
Here’s my solution:

defmodule Day10 do
  defguardp is_opening(paren) when paren in [?(, ?[, ?{, ?<]

  defguardp matches(opening, closing) when opening == ?( and closing == ?)
  defguardp matches(opening, closing) when opening in [?[, ?{, ?<] and closing == opening + 2

  @illegal_points %{
    ?) => 3,
    ?] => 57,
    ?} => 1197,
    ?> => 25137
  }

  @incomplete_points %{
    ?) => 1,
    ?] => 2,
    ?} => 3,
    ?> => 4
  }

  @doc """
      iex>Day10.part1(\"""
      ...>[({(<(())[]>[[{[]{<()<>>
      ...>[(()[<>])]({[<{<<[]>>(
      ...>{([(<{}[<>[]}>{[]{[(<()>
      ...>(((({<>}<{<{<>}{[]{[]{}
      ...>[[<[([]))<([[{}[[()]]]
      ...>[{[{({}]{}}([{[{{{}}([]
      ...>{<[[]]>}<{[{[{[]{()[[[]
      ...>[<(<(<(<{}))><([]([]()
      ...><{([([[(<>()){}]>(<<{{
      ...><{([{{}}[<[[[<>{}]]]>[]]
      ...>\""")
      26397
  """
  def part1(input) do
    input
    |> parse_input()
    |> Enum.map(fn subsystem -> visit(subsystem, []) end)
    |> Enum.filter(&(elem(&1, 0) == :illegal))
    |> Enum.map(fn {_, paren} -> @illegal_points[paren] end)
    |> Enum.sum()
  end

  @doc """
      iex>Day10.part2(\"""
      ...>[({(<(())[]>[[{[]{<()<>>
      ...>[(()[<>])]({[<{<<[]>>(
      ...>{([(<{}[<>[]}>{[]{[(<()>
      ...>(((({<>}<{<{<>}{[]{[]{}
      ...>[[<[([]))<([[{}[[()]]]
      ...>[{[{({}]{}}([{[{{{}}([]
      ...>{<[[]]>}<{[{[{[]{()[[[]
      ...>[<(<(<(<{}))><([]([]()
      ...><{([([[(<>()){}]>(<<{{
      ...><{([{{}}[<[[[<>{}]]]>[]]
      ...>\""")
      288957
  """
  def part2(input) do
    points =
      input
      |> parse_input()
      |> Enum.map(fn subsystem -> visit(subsystem, []) end)
      |> Enum.filter(&(elem(&1, 0) == :incomplete))
      |> Enum.map(fn {_, expected} ->
        expected
        |> Enum.map(&@incomplete_points[&1])
        |> Enum.reduce(0, fn points, score ->
          score * 5 + points
        end)
      end)
      |> Enum.sort()

    Enum.at(points, div(length(points), 2))
  end

  defp visit([opening, closing | input], expected) when matches(opening, closing) do
    visit(input, expected)
  end

  defp visit([closing | input], [closing | expected]) do
    visit(input, expected)
  end

  defp visit([opening | input], expected) when is_opening(opening) do
    visit(input, [pair(opening) | expected])
  end

  defp visit([illegal | _], _), do: {:illegal, illegal}
  defp visit([], expected), do: {:incomplete, expected}

  defp pair(?(), do: ?)
  defp pair(paren) when paren in [?[, ?{, ?<], do: paren + 2

  defp parse_input(input) when is_binary(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&to_charlist/1)
  end
end

Nice use of guards. I always forget about that aspect of Elixir.