Support ... in tuple patterns

[rodrigues]

... now works inside tuple patterns, and matches consistently across every tuple arity — including 2-tuples, which were silently skipped:

Pattern	Matches
{...}	any tuple, including {} and 2-tuples
{:ok, ...}	any tuple whose leading element is :ok
{..., :done}	any tuple whose trailing element is :done
{a, b, ...}	any tuple of ≥2 elements, capturing the first two
{first, ..., last}	captures both ends; ... absorbs the middle

Fixed-length tuple patterns ({:ok, _}, {a, b}, {1, 2, 3}) are unchanged: still an exact-length match.

Before

$ mix ex_ast.search "{...}" lib | rg ok
  {:ok, name, arity}
  {:ok, identifier_name(name), 0}
  {:ok, identifier_name(name), length(args)}
  {:ok, _ast, comments}

Didn't return 2-arity tuples, like {:ok, _}.

$ mix ex_ast.search "{:ok, ...}" lib

0 match(es)

After

$ mix ex_ast.search "{...}" lib | rg ok
  {:ok, right_id}
  {:ok, right_id}
  ...

$ mix ex_ast.search "{:ok, ...}" lib
lib/ex_ast.ex:389
  {:ok, matches}

lib/ex_ast/diff/matcher.ex:48
  {:ok, right_id}

lib/ex_ast/diff/matcher.ex:80
  {:ok, right_id}

…

$ mix ex_ast.search "{first, ..., last}" lib/ex_ast/ident.ex
lib/ex_ast/ident.ex:31
  {:ok, parsed, rest}
  first: :ok
  last: rest

1 match(es)

Map and keyword patterns (%{a: 1}, [a: 1]) are unaffected — their entries are also {key, value} 2-tuples, and they keep matching as before.

Edit: Adding a commit that fixes a case where a 2-tuple sub-pattern matched nothing when it appeared as a call/operator argument or a list element, such as the LHS of {:ok, _} = _, with {:ok, _} <- _, or [{:ok, _}], because the pattern kept its bare shape while the source folded it; do_match now reconciles the two.

[dannote]

Tuple ellipsis looks good overall; there's one regression with quoted ASTs.

[dannote]

This makes pattern normalization and source normalization asymmetric. A plain quoted source tuple stays {a, b}, while the pattern is folded to {:{}, nil, [...]}:

Pattern.match(
  quote(do: {:ok, value}),
  quote(do: {:ok, _})
)
# :error

Could you normalize both paths the same way (or handle the reverse shape) and add a test with an ordinary quote source?