add a test for the error, and fix small bug

compiler-core/src/parse.rs

···
                         // Give a better error when there is two consecutive spreads
                         // like `[..wibble, ..wabble, woo]`. However, if there's other
                         // elements after the tail of the list
+                        println!("{:#?}", self.tok0);
+                        println!("{:#?}", elements_after_tail);
+
                         if let Some((second_start, second_end)) = self.maybe_one(&Token::DotDot) {
                             let _second_tail = self.parse_expression();
-                            if elements_after_tail.is_none() {
+
+                            if elements_after_tail.is_none()
+                                || elements_after_tail
+                                    .as_ref()
+                                    .is_some_and(|vec| vec.is_empty())
+                            {
                                 return parse_error(
                                     ParseErrorType::ListSpreadWithAnotherSpread {
                                         first_spread_location: SrcSpan { start, end },

compiler-core/src/parse/snapshots/gleam_core__parse__tests__list_spread_followed_by_other_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  [1, ..xs, ..ys]\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() -> Nil {
+  let xs = [1, 2, 3]
+  let ys = [5, 6, 7]
+  [1, ..xs, ..ys]
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:5:13
+  │
+5 │   [1, ..xs, ..ys]
+  │       --    ^^ I wasn't expecting a second spread here
+  │       │      
+  │       You're using 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.