yeast: Explicitly warn on nested captured repetitions

This is a weird pattern (that we don't use) that had weird semantics
previously.

A minimal example would be something like

```
((item)* (separator))* @Items
```

Here, it's not really clear what @Items should be capturing. The current
implementation (post-AST rewrite) simply panics at compile-time, with a
message that may or may not be helpful. As the Copilot review correctly
points out, this is a regression compared to the previous behaviour
(which dealt with the issue by just throwing away the `(item)*` bit).
This compiled, but I don't think the old behaviour is particularly
sensible either.

For that reason, we now explicitly warn that capturing a group
containing a nested repetition is an error.

At present, we never employ the above pattern in our code. If this
changes, then we'll likely want to provide a sensible semantics for this
case rather than just panicking.

Author: tausbn

shared/yeast-macros/src/rule_parse.rs

@@ -213,6 +213,18 @@ fn maybe_repeat(tokens: &mut Tokens, pattern: Pattern) -> Result<Pattern> {
         });
     }
 
+    if matches!(
+        &pattern,
+        Pattern::Sequence(patterns)
+            if patterns.iter().any(|pattern| matches!(pattern, Pattern::Repeated { .. }))
+    ) {
+        return Err(syn::Error::new_spanned(
+            tokens.peek().unwrap().clone(),
+            "cannot capture a repeated group containing a nested repetition; \
+             capture the desired inner patterns explicitly",
+        ));
+    }
+
     let (name, raw) = consume_capture(tokens)?;
     Ok(match pattern {
         Pattern::Sequence(patterns) => Pattern::Repeated {
@@ -539,4 +551,17 @@ mod tests {
         assert_eq!(*cardinality, Cardinality::ZERO_OR_MORE);
         assert!(matches!(captured.as_ref(), Pattern::Node { .. }));
     }
+
+    #[test]
+    fn rejects_capture_on_repeated_group_with_nested_repetition() {
+        let result = parse_pattern(quote!((root ((item)* (separator))* @items)));
+        let Err(error) = result else {
+            panic!("expected nested repetition capture to be rejected");
+        };
+        assert_eq!(
+            error.to_string(),
+            "cannot capture a repeated group containing a nested repetition; \
+             capture the desired inner patterns explicitly"
+        );
+    }
 }