My approach to make it not only fast, but also clean and readable:

defmodule Solution do
  def read(path) do
    path
    |> File.stream!()
    |> Enum.map(&String.trim/1)
    |> Enum.map(&parse/1)
  end

  defp parse(input) do
    [spec, pass] = String.split(input, ": ", parts: 2)
    [range, <<char>>] = String.split(spec, " ", parts: 2)
    [min, max] =
      range
      |> String.split("-", parts: 2)
      |> Enum.map(&String.to_integer/1)

    {min..max, char, pass}
  end

  def validate_1({range, char, pass}) do
    count = for <<^char <- pass>>, reduce: 0, do: (n -> n + 1)

    count in range
  end

  def validate_2({a..b, char, pass}) do
    <<char_1>> = binary_part(pass, a - 1, 1)
    <<char_2>> = binary_part(pass, b - 1, 1)

    char_1 != char_2 and char in [char_1, char_2]
  end
end

data = Solution.read("2/input.txt")

IO.inspect(Enum.count(data, &Solution.validate_1/1), label: "task 1")
IO.inspect(Enum.count(data, &Solution.validate_2/1), label: "task 2")

Following should work:

(String.at(password, i - 1) == char) != (String.at(password, j - 1) == char)

Short solution part 1:

File.stream!("input")
|> Stream.filter(fn str ->
  [_, min, max, char, pass] = Regex.run(~r/^(\d+)-(\d+) (.): (\S+)/, str)
  count = String.graphemes(pass) |> Enum.frequencies() |> Map.get(char, 0)
  count >= String.to_integer(min) && count <= String.to_integer(max)
end)
|> Enum.count()
|> IO.puts()

Mostly what @stevensonmt said. The pin operator is needed to filter characters, as generator will allow only matches, in other words it is the same as:

for <<c <- pass>>, match?(^char, c), …

Which in the end behaves exactly the same as:

for <<c <- pass>>, char == c, …

But is shorter and a little bit more confusing definition of such behaviour.

The rest is new, as you have spotted, syntax for defining reduction. In short:

for item <- generator, reduce: x, do: (n -> …)

Is the same as:

Enum.reduce(generator, x, fn item n -> … end)

So in the end it just count characters that match given byte.

Seems no one stumbled upon :erang.xor

defmodule Event2 do
  def run do
    IO.puts("Test part1: #{part1("input/event2/test.txt")}")
    IO.puts("Puzzle part1: #{part1("input/event2/puzzle.txt")}")
    IO.puts("Test part2: #{part2("input/event2/test.txt")}")
    IO.puts("Puzzle part2: #{part2("input/event2/puzzle.txt")}")
  end

  def part1(path), do: input_stream(path) |> Stream.filter(&filter_fun/1) |> Enum.count()
  def part2(path), do: input_stream(path) |> Stream.filter(&filter_fun2/1) |> Enum.count()

  def input_stream(path), do: path |> File.stream!() |> Stream.map(&parse_input/1)

  def parse_input(input) do
    [low, high, letter, pass] = String.trim(input) |> String.split(~r/[-: ]/, trim: true)
    {String.to_integer(low), String.to_integer(high), letter, pass}
  end

  def filter_fun({low, high, letter, pass}) do
    pass_letter_count = pass |> String.graphemes() |> Enum.count(&(&1 == letter))
    low <= pass_letter_count and pass_letter_count <= high
  end

  def filter_fun2({low, high, letter, pass}),
    do: :erlang.xor(String.at(pass, low - 1) == letter, String.at(pass, high - 1) == letter)
end