[CodeGeneration] Minimize per-type parse(from:) code

Use a delegating function `SyntaxProtocol.parse(from:parse:)` similar to
the collection node version
`SyntaxCollection.parse(from:parse:makeMissing`.

Author: rintaro

CodeGeneration/Sources/generate-swift-syntax/templates/swiftparser/LayoutNodesParsableFile.swift

@@ -25,23 +25,38 @@ let layoutNodesParsableFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     }
     """
   )
+  DeclSyntax(
+    """
+    extension SyntaxParseable {
+      fileprivate static func parse(
+        from parser: inout Parser,
+        parse: (_ parser: inout Parser) -> some RawSyntaxNodeProtocol
+      ) -> Self {
+        // Keep the parser alive so that the arena in which `raw` is allocated
+        // doesn’t get deallocated before we have a chance to create a syntax node
+        // from it. We can’t use `parser.arena` as the parameter to
+        // `Syntax(raw:arena:)` because the node might have been re-used during an
+        // incremental parse and would then live in a different arena than
+        // `parser.arena`.
+        defer {
+          withExtendedLifetime(self) {
+          }
+        }
+        let node = parse(&parser)
+        let raw = RawSyntax(parser.parseRemainder(into: node))
+        return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+      }
+    }
+    """
+  )
 
   for node in SYNTAX_NODES {
     if let parserFunction = node.parserFunction {
       DeclSyntax(
         """
         extension \(node.kind.syntaxType): SyntaxParseable {
           public static func parse(from parser: inout Parser) -> Self {
-            // Keep the parser alive so that the arena in which `raw` is allocated
-            // doesn’t get deallocated before we have a chance to create a syntax node
-            // from it. We can’t use `parser.arena` as the parameter to
-            // `Syntax(raw:arena:)` because the node might have been re-used during an
-            // incremental parse and would then live in a different arena than
-            // `parser.arena`.
-            defer { withExtendedLifetime(parser) {} }
-            let node = parser.\(parserFunction)()
-            let raw = RawSyntax(parser.parseRemainder(into: node))
-            return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+            parse(from: &parser) { $0.\(parserFunction)() }
           }
         }
         """