C#: Add documentation comment LST infrastructure (#7015)

Add a structured LST for C# XML documentation comments (///) following
the same architectural pattern as Java's Javadoc support: separate tree
hierarchy, visitor with bidirectional CSharpVisitor bridge, and printer.

Java side:
- CsDocComment interface (extends Tree) with 8 node types: DocComment,
  XmlElement, XmlEmptyElement, XmlText, XmlAttribute, XmlCrefAttribute,
  XmlNameAttribute, LineBreak
- CsDocCommentVisitor with bridge to CSharpVisitor for cref references
- CsDocCommentPrinter for serializing back to /// XML format
- CsDocCommentParser for converting raw text to structured tree
- CsDocCommentRawComment for RPC-compatible raw comment transport
- CSharpVisitor.visitSpace() override to detect and process doc comments

C# side:
- XmlDocComment class extending Comment for grouped /// lines
- FormatWithComments groups consecutive /// lines into single XmlDocComment
- CSharpPrinter handles XmlDocComment output
- RPC type mappings for XmlDocComment <-> CsDocCommentRawComment

Author: jkschneider

rewrite-csharp/csharp/OpenRewrite/CSharp/CSharpPrinter.cs

@@ -2877,7 +2877,12 @@ protected void VisitSpace(Space space, PrintOutputCapture<P> p)
         p.Append(space.Whitespace);
         foreach (var comment in space.Comments)
         {
-            if (comment.Multiline)
+            if (comment is XmlDocComment)
+            {
+                // XmlDocComment text starts after "//" — printer prepends "//"
+                p.Append("//").Append(comment.Text);
+            }
+            else if (comment.Multiline)
             {
                 p.Append("/*").Append(comment.Text).Append("*/");
             }

rewrite-csharp/csharp/OpenRewrite/Core/Rpc/RpcReceiveQueue.cs

@@ -441,6 +441,7 @@ private static bool IsTreeType(object obj)
         {
             "org.openrewrite.java.tree.Space" => typeof(Space),
             "org.openrewrite.java.tree.TextComment" => typeof(TextComment),
+            "org.openrewrite.csharp.tree.CsDocCommentRawComment" => typeof(XmlDocComment),
             "org.openrewrite.marker.Markers" => typeof(Markers),
             "org.openrewrite.marker.SearchResult" => typeof(SearchResult),
             "org.openrewrite.marker.RecipesThatMadeChanges" => typeof(RecipesThatMadeChanges),

rewrite-csharp/csharp/OpenRewrite/Core/Rpc/RpcSendQueue.cs

@@ -350,6 +350,7 @@ private void DoChange(object? after, object? before, Action? onChange, IRpcCodec
                 "Markup" => "org.openrewrite.marker.Markup",
                 "Space" => "org.openrewrite.java.tree.Space",
                 "TextComment" => "org.openrewrite.java.tree.TextComment",
+                "XmlDocComment" => "org.openrewrite.csharp.tree.CsDocCommentRawComment",
                 "Checksum" => "org.openrewrite.Checksum",
                 "FileAttributes" => "org.openrewrite.FileAttributes",
                 _ => null,

rewrite-csharp/csharp/OpenRewrite/Core/Space.cs

@@ -185,6 +185,43 @@ public static Space FormatWithComments(string formatting)
             }
         }
 
+        // Group consecutive /// doc comments into a single XmlDocComment.
+        // After rotation, doc comment lines are TextComment with text starting with "/".
+        if (comments.Count > 0)
+        {
+            var grouped = new List<Comment>();
+            int j = 0;
+            while (j < comments.Count)
+            {
+                var cmt = comments[j];
+                if (cmt is TextComment tc && !tc.Multiline && tc.Text.StartsWith("/"))
+                {
+                    // Start of a doc comment block — group consecutive /// lines.
+                    var sb = new System.Text.StringBuilder();
+                    sb.Append(tc.Text);
+                    string lastSuffix = tc.Suffix;
+                    j++;
+                    while (j < comments.Count &&
+                           comments[j] is TextComment next && !next.Multiline &&
+                           next.Text.StartsWith("/"))
+                    {
+                        sb.Append(lastSuffix);
+                        sb.Append("//");
+                        sb.Append(next.Text);
+                        lastSuffix = next.Suffix;
+                        j++;
+                    }
+                    grouped.Add(new XmlDocComment(sb.ToString(), lastSuffix, true));
+                }
+                else
+                {
+                    grouped.Add(cmt);
+                    j++;
+                }
+            }
+            comments = grouped;
+        }
+
         return comments.Count > 0 ? new Space(ws, comments) : Build(formatting, []);
     }
 
@@ -212,3 +249,11 @@ public abstract class Comment(string text, string suffix, bool multiline)
 /// </summary>
 public sealed class TextComment(string text, string suffix, bool multiline)
     : Comment(text, suffix, multiline);
+
+/// <summary>
+/// An XML documentation comment (///) block.
+/// The Text property contains the raw content after the initial "//",
+/// including continuation "///" prefixes on subsequent lines.
+/// </summary>
+public sealed class XmlDocComment(string text, string suffix, bool multiline)
+    : Comment(text, suffix, multiline);

rewrite-csharp/src/main/java/org/openrewrite/csharp/CSharpVisitor.java

@@ -35,11 +35,46 @@
 
 public class CSharpVisitor<P> extends JavaVisitor<P>
 {
+    protected CsDocCommentVisitor<P> csXmlDocVisitor;
+
     @Override
     public boolean isAcceptable(SourceFile sourceFile, P p) {
         return sourceFile instanceof Cs;
     }
 
+    protected CsDocCommentVisitor<P> getCsDocCommentVisitor() {
+        return new CsDocCommentVisitor<>(this);
+    }
+
+    @Override
+    public Space visitSpace(@Nullable Space space, Space.Location loc, P p) {
+        if (space == Space.EMPTY || space == Space.SINGLE_SPACE || space == null) {
+            return space;
+        } else if (space.getComments().isEmpty()) {
+            return space;
+        }
+        return space.withComments(ListUtils.map(space.getComments(), comment -> {
+            if (comment instanceof CsDocCommentRawComment) {
+                // Convert raw doc comment from RPC into structured tree, then visit
+                CsDocComment.DocComment parsed = CsDocCommentParser.parse((CsDocCommentRawComment) comment);
+                return visitCsDocCommentComment(parsed, p);
+            } else if (comment instanceof CsDocComment.DocComment) {
+                return visitCsDocCommentComment((CsDocComment.DocComment) comment, p);
+            }
+            return comment;
+        }));
+    }
+
+    private Comment visitCsDocCommentComment(CsDocComment.DocComment docComment, P p) {
+        if (csXmlDocVisitor == null) {
+            csXmlDocVisitor = getCsDocCommentVisitor();
+        }
+        Cursor previous = csXmlDocVisitor.getCursor();
+        Comment c = (Comment) csXmlDocVisitor.visit(docComment, p, getCursor());
+        csXmlDocVisitor.setCursor(previous);
+        return c;
+    }
+
     public J visitCompilationUnit(Cs.CompilationUnit compilationUnit, P p) {
         compilationUnit = compilationUnit.withPrefix(visitSpace(compilationUnit.getPrefix(), Space.Location.COMPILATION_UNIT_PREFIX, p));
         compilationUnit = compilationUnit.withMarkers(visitMarkers(compilationUnit.getMarkers(), p));