Add standalone test projects for all C# PEG simplification solutions

This commit adds runnable test projects for each solution approach
documented in the case study. Each project demonstrates the specific
behavior (success, partial success, or failure) of that approach:

- Solution 01: #parse{} expression - demonstrates PEG0011 build error
- Solution 02: capture-validate - shows disambiguation failure
- Solution 03: semantic predicates - shows input access limitation
- Solution 04: hybrid approach - full working solution
- Solution 05: minimized hybrid - optimized production implementation

Each project can be run independently with:
  cd solutions/<name>/project && dotnet build && dotnet run

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: konard

docs/case-studies/csharp-peg-simplification/README.md

@@ -192,15 +192,38 @@ highQuoteCapture <string> = raw:highQuoteDoubleRaw &{ ParseMultiQuoteString(raw,
 docs/case-studies/csharp-peg-simplification/
 ├── README.md                    # This file
 ├── timeline.md                  # Detailed timeline with timestamps
-├── root-causes.md              # Deep dive into each root cause
-├── solutions/                   # Experimental solutions
-│   ├── 01-parse-expression/    # #parse{} approach
-│   ├── 02-capture-validate/    # Capture-then-validate approach
-│   ├── 03-semantic-predicates/ # Semantic predicates approach
-│   └── 04-other-approaches/    # Other attempted solutions
-└── experiments/                 # Standalone experiment files
+├── root-causes.md               # Deep dive into each root cause
+└── solutions/                   # All attempted solutions with runnable test projects
+    ├── 01-parse-expression/     # #parse{} approach (FAILED - PEG0011 error)
+    │   ├── README.md
+    │   └── project/             # Runnable test project demonstrating the error
+    ├── 02-capture-validate/     # Capture-then-validate (PARTIAL - disambiguation fails)
+    │   ├── README.md
+    │   └── project/             # Runnable test project
+    ├── 03-semantic-predicates/  # Semantic predicates (FAILED - no input access)
+    │   ├── README.md
+    │   └── project/             # Runnable test project
+    ├── 04-hybrid-approach/      # Hybrid N=1-5 explicit + N>=6 procedural (SUCCESS)
+    │   ├── README.md
+    │   └── project/             # Runnable test project
+    └── 05-minimized-hybrid/     # CURRENT: N=1,2 explicit + N>=3 procedural (SUCCESS)
+        ├── README.md
+        └── project/             # Runnable test project
 ```
 
+### Running the Test Projects
+
+Each solution has a standalone test project. To run:
+
+```bash
+cd solutions/<solution-name>/project
+dotnet build
+dotnet run
+```
+
+Solution 01 will fail to build (demonstrating the PEG0011 error).
+Solutions 02-05 will build and run, showing their respective behaviors.
+
 ## References
 
 - [Peggy.js Documentation](https://peggyjs.org/documentation.html)

docs/case-studies/csharp-peg-simplification/solutions/01-parse-expression/project/Program.cs

@@ -0,0 +1,30 @@
+// This program demonstrates the #parse{} approach failure
+// When you run 'dotnet build', you will see error PEG0011
+
+using System;
+
+namespace TestParseExpression
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("=== Test: #parse{} Expression Approach ===");
+            Console.WriteLine();
+            Console.WriteLine("This test demonstrates that #parse{} expressions");
+            Console.WriteLine("do NOT work with the <PegGrammar> MSBuild tag.");
+            Console.WriteLine();
+            Console.WriteLine("Expected build error:");
+            Console.WriteLine("  error PEG0011: Unterminated code section.");
+            Console.WriteLine();
+            Console.WriteLine("If you see this message, the grammar compiled");
+            Console.WriteLine("successfully, which means the bug may have been fixed!");
+            Console.WriteLine();
+
+            // This code won't execute because the project won't compile
+            // var parser = new QuoteParser();
+            // var result = parser.Parse("\"hello\"");
+            // Console.WriteLine($"Parsed: {result}");
+        }
+    }
+}

docs/case-studies/csharp-peg-simplification/solutions/01-parse-expression/project/QuoteParser.peg

@@ -0,0 +1,107 @@
+@namespace TestParseExpression
+@classname QuoteParser
+@using System.Linq
+
+@members
+{
+    private string _parsedValue = "";
+    private int _parsedLength;
+
+    /// <summary>
+    /// Universal parser for N-quote strings.
+    /// Handles any quote character and any number N of quotes.
+    /// </summary>
+    private bool ParseQuotedStringAt(string input, int startPos, char quoteChar)
+    {
+        if (startPos >= input.Length || input[startPos] != quoteChar)
+            return false;
+
+        // Count opening quotes
+        int quoteCount = 0;
+        int pos = startPos;
+        while (pos < input.Length && input[pos] == quoteChar)
+        {
+            quoteCount++;
+            pos++;
+        }
+
+        string closeSeq = new string(quoteChar, quoteCount);
+        string escapeSeq = new string(quoteChar, quoteCount * 2);
+        var content = new System.Text.StringBuilder();
+
+        while (pos < input.Length)
+        {
+            // Check for escape sequence (2*N quotes)
+            if (pos + escapeSeq.Length <= input.Length &&
+                input.Substring(pos, escapeSeq.Length) == escapeSeq)
+            {
+                content.Append(closeSeq);
+                pos += escapeSeq.Length;
+                continue;
+            }
+
+            // Check for closing sequence (exactly N quotes)
+            if (pos + quoteCount <= input.Length &&
+                input.Substring(pos, quoteCount) == closeSeq)
+            {
+                int afterClose = pos + quoteCount;
+                if (afterClose >= input.Length || input[afterClose] != quoteChar)
+                {
+                    _parsedValue = content.ToString();
+                    _parsedLength = afterClose - startPos;
+                    return true;
+                }
+            }
+
+            content.Append(input[pos]);
+            pos++;
+        }
+        return false;
+    }
+}
+
+document <string> = q:quoted { q }
+
+// Universal quoted string - handles any N quotes
+// THIS DOES NOT WORK with <PegGrammar> tag due to PEG0011 error
+quoted <string> = doubleQuoted / singleQuoted / backtickQuoted
+
+// THESE RULES USE #parse{} WHICH CAUSES PEG0011 ERROR
+// The #parse{} syntax allows custom procedural parsing but is not
+// properly supported when using the <PegGrammar> MSBuild tag.
+
+doubleQuoted <string> = #parse{
+    if (ParseQuotedStringAt(subject, startCursor.Location, '"'))
+    {
+        return new Pegasus.Common.ParseResult<string>(
+            ref startCursor,
+            startCursor.Advance(_parsedLength),
+            _parsedValue
+        );
+    }
+    return null;
+}
+
+singleQuoted <string> = #parse{
+    if (ParseQuotedStringAt(subject, startCursor.Location, '\''))
+    {
+        return new Pegasus.Common.ParseResult<string>(
+            ref startCursor,
+            startCursor.Advance(_parsedLength),
+            _parsedValue
+        );
+    }
+    return null;
+}
+
+backtickQuoted <string> = #parse{
+    if (ParseQuotedStringAt(subject, startCursor.Location, '`'))
+    {
+        return new Pegasus.Common.ParseResult<string>(
+            ref startCursor,
+            startCursor.Advance(_parsedLength),
+            _parsedValue
+        );
+    }
+    return null;
+}

docs/case-studies/csharp-peg-simplification/solutions/01-parse-expression/project/TestParseExpression.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Pegasus" Version="4.1.0" />
+    <!-- Using PegGrammar tag triggers PEG0011 error for #parse{} -->
+    <PegGrammar Include="QuoteParser.peg" />
+  </ItemGroup>
+</Project>

docs/case-studies/csharp-peg-simplification/solutions/02-capture-validate/project/Program.cs

@@ -0,0 +1,84 @@
+// This program demonstrates the capture-then-validate approach
+// It shows both SUCCESS (isolated strings) and FAILURE (disambiguation)
+
+using System;
+
+namespace TestCaptureValidate
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("=== Test: Capture-then-Validate Approach ===");
+            Console.WriteLine();
+
+            var parser = new QuoteParser();
+
+            // Test cases that WORK (isolated strings)
+            var successCases = new (string input, string expected)[]
+            {
+                ("\"hello\"", "hello"),
+                ("\"\"world\"\"", "world"),
+                ("\"\"\"foo\"\"\"", "foo"),
+                ("'text'", "text"),
+                ("''escaped''", "escaped"),
+                ("`backtick`", "backtick"),
+                ("\"\"with \"\"\"\" escape\"\"", "with \"\" escape"),
+            };
+
+            Console.WriteLine("=== Isolated String Tests (Expected: SUCCESS) ===");
+            int passed = 0, failed = 0;
+            foreach (var (input, expected) in successCases)
+            {
+                try
+                {
+                    var result = parser.Parse(input);
+                    if (result == expected)
+                    {
+                        Console.WriteLine($"✓ {input} → \"{result}\"");
+                        passed++;
+                    }
+                    else
+                    {
+                        Console.WriteLine($"✗ {input} → \"{result}\" (expected: \"{expected}\")");
+                        failed++;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"✗ {input} → Error: {ex.Message}");
+                    failed++;
+                }
+            }
+
+            Console.WriteLine();
+            Console.WriteLine("=== Multiple String Tests (Expected: FAILURE) ===");
+            Console.WriteLine("These tests demonstrate the disambiguation problem:");
+            Console.WriteLine();
+
+            // Test case that FAILS due to greedy disambiguation
+            var multiInput = "\"first\" \"second\"";
+            try
+            {
+                var result = parser.Parse(multiInput);
+                Console.WriteLine($"Input: {multiInput}");
+                Console.WriteLine($"Result: \"{result}\"");
+                Console.WriteLine("PROBLEM: Greedy pattern captured from first \" to last \"");
+                Console.WriteLine("Expected: Two separate strings \"first\" and \"second\"");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Input: {multiInput}");
+                Console.WriteLine($"Error: {ex.Message}");
+                Console.WriteLine("This failure is expected - greedy patterns can't disambiguate");
+            }
+
+            Console.WriteLine();
+            Console.WriteLine($"=== Summary ===");
+            Console.WriteLine($"Isolated strings: {passed} passed, {failed} failed");
+            Console.WriteLine();
+            Console.WriteLine("CONCLUSION: Capture-then-validate works for isolated strings");
+            Console.WriteLine("but FAILS for disambiguation of multiple quoted strings.");
+        }
+    }
+}

docs/case-studies/csharp-peg-simplification/solutions/02-capture-validate/project/QuoteParser.peg

@@ -0,0 +1,92 @@
+@namespace TestCaptureValidate
+@classname QuoteParser
+@using System.Linq
+
+@members
+{
+    private string _parsedValue = "";
+
+    /// <summary>
+    /// Parse captured text as an N-quote string.
+    /// The captured text should include opening and closing quotes.
+    /// </summary>
+    private bool TryParseQuotedString(string capturedText, char quoteChar)
+    {
+        _parsedValue = "";
+        if (string.IsNullOrEmpty(capturedText) || capturedText[0] != quoteChar)
+            return false;
+
+        // Count opening quotes
+        int quoteCount = 0;
+        int pos = 0;
+        while (pos < capturedText.Length && capturedText[pos] == quoteChar)
+        {
+            quoteCount++;
+            pos++;
+        }
+
+        string closeSeq = new string(quoteChar, quoteCount);
+        string escapeSeq = new string(quoteChar, quoteCount * 2);
+        var content = new System.Text.StringBuilder();
+
+        while (pos < capturedText.Length)
+        {
+            // Check for escape sequence (2*N quotes)
+            if (pos + escapeSeq.Length <= capturedText.Length &&
+                capturedText.Substring(pos, escapeSeq.Length) == escapeSeq)
+            {
+                content.Append(closeSeq);
+                pos += escapeSeq.Length;
+                continue;
+            }
+
+            // Check for closing sequence
+            if (pos + quoteCount <= capturedText.Length &&
+                capturedText.Substring(pos, quoteCount) == closeSeq)
+            {
+                int afterClose = pos + quoteCount;
+                if (afterClose >= capturedText.Length || capturedText[afterClose] != quoteChar)
+                {
+                    // Valid closing - check if we consumed entire captured text
+                    if (afterClose == capturedText.Length)
+                    {
+                        _parsedValue = content.ToString();
+                        return true;
+                    }
+                    // Captured more than one quoted string (disambiguation problem)
+                    return false;
+                }
+            }
+
+            content.Append(capturedText[pos]);
+            pos++;
+        }
+        return false;
+    }
+}
+
+// Entry point: parse a single quoted string
+document <string> = q:quoted { q }
+
+// Try to parse quoted strings using capture-then-validate
+// NOTE: This has disambiguation problems with multiple quoted strings
+quoted <string> = doubleQuoted / singleQuoted / backtickQuoted
+
+// Double quotes: capture greedy pattern, then validate
+doubleQuoted <string> = raw:doubleQuoteCaptureRaw &{ TryParseQuotedString(raw, '"') } { _parsedValue }
+
+// Capture pattern for double quotes
+// Matches: one or more ", then content, then one or more "
+// WARNING: Greedy - will match from first " to LAST " in input
+doubleQuoteCaptureRaw <string> = "" ('"'+ doubleQuoteContent* '"'+)
+doubleQuoteContent = [^"] / '"'+ &[^"]
+
+// Single quotes: same pattern
+singleQuoted <string> = raw:singleQuoteCaptureRaw &{ TryParseQuotedString(raw, '\'') } { _parsedValue }
+singleQuoteCaptureRaw <string> = "" ("'"+ singleQuoteContent* "'"+)
+singleQuoteContent = [^'] / "'"+ &[^']
+
+// Backticks: same pattern
+backtickQuoted <string> = raw:backtickCaptureRaw &{ TryParseQuotedString(raw, '`') } { _parsedValue }
+backtickCaptureRaw <string> = "" ('`'+ backtickContent* '`'+)
+backtickContent = [^`] / '`'+ &[^`]

docs/case-studies/csharp-peg-simplification/solutions/02-capture-validate/project/TestCaptureValidate.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Pegasus" Version="4.1.0" />
+    <PegGrammar Include="QuoteParser.peg" />
+  </ItemGroup>
+</Project>