Track in ParserState if suspending the tokenizer is supported.

I thought that suspending the tokenizer without being in a chain would have no effect, but it actually has the effect of prohibiting subsequent suspensions.
With this change, suspending is a real no-op if the tokenizer is not wrapped in a chain.

src/FarkleNeo/Parser/ParserState.cs

@@ -63,6 +63,17 @@ public struct ParserState
     /// <seealso cref="ParserExtensions.ParseFileAsync"/>
     public string? InputName { get; set; }
 
+    /// <summary>
+    /// Whether suspending the tokenizer will have any effect.
+    /// </summary>
+    /// <remarks>
+    /// We must have this property because if the tokenizer is not wrapped in a chain
+    /// and suspends to itself (which is still supported), there is no chain to "unsuspend"
+    /// the tokenizer, and when the tokenizer returns and wants to suspend again, it will
+    /// throw with a message that it is already suspended.
+    /// </remarks>
+    internal bool TokenizerSupportsSuspending { get; set; }
+
     internal void Consume<T>(ReadOnlySpan<T> characters)
     {
         _positionTracker.Advance(characters);

src/FarkleNeo/Parser/Tokenizers/ChainedTokenizer.cs

@@ -39,6 +39,10 @@ internal static Tokenizer<TChar> Create(ImmutableArray<Tokenizer<TChar>> compone
 
     public override bool TryGetNextToken(ref ParserInputReader<TChar> input, ITokenSemanticProvider<TChar> semanticProvider, out TokenizerResult result)
     {
+        // We mark this parser operation as supporting suspending.
+        // It might cause some issues if the tokenizer changes in the middle of the
+        // operation but this is not a supported scenario.
+        input.State.TokenizerSupportsSuspending = true;
         // Get the state of the chained tokenizer. If we have not suspended before,
         // it will be null.
         var tokenizerState = input.GetChainedTokenizerStateOrNull();

src/FarkleNeo/Parser/Tokenizers/TokenizerExtensions.cs

@@ -78,6 +78,11 @@ private static void SuspendTokenizerCore<TChar>(this ref ParserInputReader<TChar
     public static void SuspendTokenizer<TChar>(this ref ParserInputReader<TChar> input, Tokenizer<TChar> tokenizer)
     {
         ArgumentNullExceptionCompat.ThrowIfNull(tokenizer);
+
+        if (!input.State.TokenizerSupportsSuspending)
+        {
+            return;
+        }
         input.SuspendTokenizerCore(tokenizer);
     }
 
@@ -119,6 +124,11 @@ public static void SuspendTokenizer<TChar, TArg>(this ref ParserInputReader<TCha
         ITokenizerResumptionPoint<TChar, TArg> resumptionPoint, TArg arg)
     {
         ArgumentNullExceptionCompat.ThrowIfNull(resumptionPoint);
+
+        if (!input.State.TokenizerSupportsSuspending)
+        {
+            return;
+        }
         input.SuspendTokenizerCore(new TokenizerResumptionPoint<TChar, TArg>(resumptionPoint, arg));
     }