Friendly error when using multiple spreads

compiler-core/src/parse.rs

···
                                 elements_after_tail = Some(elements);
                             }
                         };
+
+                        // Give a better error when there is a another spread
+                        // like `[..wibble, wobble, ..wabble]`
+                        if self.maybe_one(&Token::DotDot).is_some() {
+                          return parse_error(
+                              ParseErrorType::ListSpreadWithAnotherSpread,
+                              SrcSpan { start, end },
+                          );
+                        }
                     };
 
                     if tail.is_some() && !elements_end_with_comma {

compiler-core/src/parse/error.rs

···
                     "See: https://tour.gleam.run/basics/lists/".into(),
                 ],
             ),
+            ParseErrorType::ListSpreadWithAnotherSpread => (
+                "I wasn't expecting a spread here",
+                vec![
+                    "Lists are immutable and singly-linked, so to join two or more lists".into(),
+                    "all the elements of the lists would need to be copied into a new list.".into(),
+                    "This would be slow, so there is no built-in syntax for it.".into(),
+                ],
+            ),
             ParseErrorType::ListSpreadFollowedByElements => (
                 "I wasn't expecting elements after this",
                 vec![
···
     UnknownTarget, // an unknown target was used
     ListSpreadWithoutElements, // Pointless spread: `[..xs]`
     ListSpreadFollowedByElements, // trying to append something after the spread: `[..xs, x]`
+    ListSpreadWithAnotherSpread, // trying to use multiple spreads: `[..xs, ..ys]`
     LowcaseBooleanPattern, // most likely user meant True or False in patterns
     UnexpectedLabel, // argument labels were provided, but are not supported in this context
     UnexpectedEof,

compiler-core/src/parse/snapshots/gleam_core__parse__tests__list_spread_followed_by_another_spread.snap

···
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\npub fn main() -> Nil {\n  let xs = [1, 2, 3]\n  let ys = [5, 6, 7]\n  [..xs, 4, ..ys]\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() -> Nil {
+  let xs = [1, 2, 3]
+  let ys = [5, 6, 7]
+  [..xs, 4, ..ys]
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:5:4
+  │
+5 │   [..xs, 4, ..ys]
+  │    ^^ I wasn't expecting a spread here
+
+Lists are immutable and singly-linked, so to join two or more lists
+all the elements of the lists would need to be copied into a new list.
+This would be slow, so there is no built-in syntax for it.

compiler-core/src/parse/tests.rs

···
 }
 
 #[test]
+fn list_spread_followed_by_another_spread() {
+    assert_module_error!(
+        r#"
+pub fn main() -> Nil {
+  let xs = [1, 2, 3]
+  let ys = [5, 6, 7]
+  [..xs, 4, ..ys]
+}
+"#
+    );
+}
+
+#[test]
 fn list_spread_as_first_item_followed_by_other_items() {
     assert_module_error!(
         r#"