fix: align ellipsis and range-step parsing with Elixir

Update parser semantics around ellipsis and range-step handling to match Elixir behavior for edge cases involving //.

What changed:

- In parse_infix_expression/2, handle infix // as a range-step operator only when the lhs is a range node, producing :..//.

- For non-range lhs, record the same range-step diagnostic intent Elixir uses, instead of silently accepting a generic binary //.

- In parse_ellipsis_op/1, treat :ternary_op as a continuation candidate rather than a standalone-ellipsis stop token, which fixes newline forms like x...\n//y.

- Add a regression test asserting non-range // produces an error path for x...//y.

Why:

The previous behavior diverged from Elixir in two directions: it accepted non-range infix // and parsed x...\n//y as ternary continuation instead of preserving ellipsis unary continuation semantics. This change resolves both at grammar/parse semantics level rather than adding context-specific lookahead hacks.

Special considerations:

- Tokenizer behavior was already aligned with Elixir for these inputs; the fix is parser-only.

- Existing semicolon-separated ellipsis cases remain covered and passing.

Author: mkaput

lib/spitfire.ex

@@ -1423,8 +1423,28 @@ defmodule Spitfire do
             {rhs, parser}
         end
 
+      parser =
+        if token == :"//" and not match?({:.., _, [_, _]}, lhs) do
+          put_error(
+            pre_parser,
+            {meta,
+             "the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\) instead. Syntax error before: '//'"}
+          )
+        else
+          parser
+        end
+
       ast =
         case token do
+          :"//" ->
+            case lhs do
+              {:.., lhs_meta, [left, middle]} ->
+                {:..//, lhs_meta, [left, middle, rhs]}
+
+              _ ->
+                {token, newlines ++ meta, [lhs, rhs]}
+            end
+
           :"not in" ->
             {:not, meta, [{:in, meta, [lhs, rhs]}]}
 
@@ -2927,7 +2947,7 @@ defmodule Spitfire do
       if MapSet.member?(@terminals_with_comma, peek_token(parser)) or
            peek_token(parser) == :";" or
            peek in [:stab_op, :do, :end, :block_identifier] or
-           (is_binary_op?(peek) and peek != :dual_op) do
+           (is_binary_op?(peek) and peek not in [:dual_op, :ternary_op]) do
         {{:..., current_meta(parser), []}, parser}
       else
         meta = current_meta(parser)

test/spitfire_test.exs

@@ -2321,6 +2321,20 @@ defmodule SpitfireTest do
                 [{[line: 1, column: 5], "unknown token: %"}]}
     end
 
+    test "range step operator requires a range lhs" do
+      code = "x...//y"
+
+      assert {:error, _} = s2q(code)
+      assert {:error, _ast, errors} = Spitfire.parse(code)
+
+      assert Enum.any?(errors, fn {_meta, message} ->
+               String.contains?(
+                 message,
+                 "the range step operator (//) must immediately follow the range definition operator (..)"
+               )
+             end)
+    end
+
     test "missing bitstring brackets" do
       code = """
       <<one::