refactor: modularize inline markdown parsing

Sources/SwiftParserShowCase/Code/Markdown/Nodes/MarkdownAdmonitionBuilder.swift

@@ -35,9 +35,16 @@ public class MarkdownAdmonitionBuilder: CodeNodeBuilder {
            let sp = context.tokens[idx] as? MarkdownToken,
            sp.element == .space { idx += 1 }
         context.consuming = idx
-        let children = MarkdownInlineParser.parseInline(&context)
         let node = AdmonitionNode(kind: kind)
-        for c in children { node.append(c) }
+        var inlineCtx = CodeConstructContext(
+            current: node,
+            tokens: context.tokens,
+            consuming: context.consuming,
+            state: context.state
+        )
+        let inlineBuilder = MarkdownInlineBuilder()
+        _ = inlineBuilder.build(from: &inlineCtx)
+        context.consuming = inlineCtx.consuming
         context.current.append(node)
         if context.consuming < context.tokens.count,
            let nl2 = context.tokens[context.consuming] as? MarkdownToken,

Sources/SwiftParserShowCase/Code/Markdown/Nodes/MarkdownBlockquoteBuilder.swift

@@ -16,10 +16,16 @@ public class MarkdownBlockquoteBuilder: CodeNodeBuilder {
            space.element == .space {
             context.consuming += 1
         }
-        // Parse inline content until a newline or EOF inside the blockquote
-        let children = MarkdownInlineParser.parseInline(&context)
         let node = BlockquoteNode()
-        for child in children { node.append(child) }
+        var inlineCtx = CodeConstructContext(
+            current: node,
+            tokens: context.tokens,
+            consuming: context.consuming,
+            state: context.state
+        )
+        let inlineBuilder = MarkdownInlineBuilder()
+        _ = inlineBuilder.build(from: &inlineCtx)
+        context.consuming = inlineCtx.consuming
         context.current.append(node)
         if context.consuming < context.tokens.count,
            let nl = context.tokens[context.consuming] as? MarkdownToken,

Sources/SwiftParserShowCase/Code/Markdown/Nodes/MarkdownDefinitionListBuilder.swift

@@ -51,16 +51,17 @@ public class MarkdownDefinitionListBuilder: CodeNodeBuilder {
             context.consuming += 1
         }
 
-        var termContext = CodeConstructContext(current: DocumentNode(), tokens: termTokens)
-        let termChildren = MarkdownInlineParser.parseInline(&termContext)
-        var defContext = CodeConstructContext(current: DocumentNode(), tokens: defTokens)
-        let defChildren = MarkdownInlineParser.parseInline(&defContext)
-
-        let item = DefinitionItemNode()
         let termNode = DefinitionTermNode()
-        for c in termChildren { termNode.append(c) }
+        var termContext = CodeConstructContext(current: termNode, tokens: termTokens, state: context.state)
+        let inlineBuilder = MarkdownInlineBuilder(stopAt: [])
+        _ = inlineBuilder.build(from: &termContext)
+
         let descNode = DefinitionDescriptionNode()
-        for c in defChildren { descNode.append(c) }
+        var defContext = CodeConstructContext(current: descNode, tokens: defTokens, state: context.state)
+        let inlineBuilder2 = MarkdownInlineBuilder(stopAt: [])
+        _ = inlineBuilder2.build(from: &defContext)
+
+        let item = DefinitionItemNode()
         item.append(termNode)
         item.append(descNode)
 

Sources/SwiftParserShowCase/Code/Markdown/Nodes/MarkdownHeadingBuilder.swift

@@ -26,10 +26,16 @@ public class MarkdownHeadingBuilder: CodeNodeBuilder {
         idx += 1
 
         context.consuming = idx
-        // Parse inline content until a newline or EOF
-        let children = MarkdownInlineParser.parseInline(&context)
         let node = HeaderNode(level: level)
-        for child in children { node.append(child) }
+        var inlineCtx = CodeConstructContext(
+            current: node,
+            tokens: context.tokens,
+            consuming: context.consuming,
+            state: context.state
+        )
+        let inlineBuilder = MarkdownInlineBuilder()
+        _ = inlineBuilder.build(from: &inlineCtx)
+        context.consuming = inlineCtx.consuming
         context.current.append(node)
 
         if context.consuming < context.tokens.count,