Support parameterized rule's arguments include inline

Support following:
```
%rule %inline op : '+'
                 | '-'
                 ;

%%

operation : op?
          ;
```

Author: ydah

lib/lrama/grammar/rule_builder.rb

@@ -56,6 +56,7 @@ def complete_input
       def setup_rules
         preprocess_references unless @skip_preprocess_references
         process_rhs
+        resolve_inline_rules
         build_rules
       end
 
@@ -79,6 +80,7 @@ def preprocess_references
 
       def build_rules
         tokens = @replaced_rhs
+        return if tokens.any? { |t| @parameterized_resolver.find_inline(t) }
 
         rule = Rule.new(
           id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, lhs_tag: lhs_tag, token_code: user_code,
@@ -152,6 +154,20 @@ def process_rhs
         end
       end
 
+      def resolve_inline_rules
+        while @rule_builders_for_parameterized.any?(&:has_inline_rules?) do
+          @rule_builders_for_parameterized = @rule_builders_for_parameterized.flat_map do |rule_builder|
+            if rule_builder.has_inline_rules?
+              inlined_builders = Inline::Resolver.new(rule_builder).resolve
+              inlined_builders.each { |builder| builder.setup_rules }
+              inlined_builders
+            else
+              rule_builder
+            end
+          end
+        end
+      end
+
       def numberize_references
         # Bison n'th component is 1-origin
         (rhs + [user_code]).compact.each.with_index(1) do |token, i|

sig/lrama/grammar/rule_builder.rbs

@@ -24,7 +24,6 @@ module Lrama
       def initialize: (Counter rule_counter, Counter midrule_action_counter, Grammar::Parameterized::Resolver parameterized_resolver, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
       def add_rhs: (Lexer::Token rhs) -> void
       def has_inline_rules?: -> bool
-      def resolve_inline_rules: -> Array[RuleBuilder]
       def user_code=: (Lexer::Token::UserCode? user_code) -> void
       def precedence_sym=: (Grammar::Symbol? precedence_sym) -> void
       def complete_input: () -> void
@@ -40,6 +39,7 @@ module Lrama
       def resolve_inline: () -> void
       def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::Parameterized::Rhs inline_rhs, Integer index, ?Binding bindings) -> void
       def replace_inline_user_code: (Grammar::Parameterized::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?
+      def resolve_inline_rules: () -> void
       def numberize_references: () -> void
       def flush_user_code: () -> void
     end

spec/fixtures/inlining/parameterized_args_include_inline.y

@@ -0,0 +1,38 @@
+/*
+ * This is comment for this file.
+ */
+
+%{
+// Prologue
+static int yylex(YYSTYPE *val, YYLTYPE *loc);
+static int yyerror(YYLTYPE *loc, const char *str);
+%}
+
+%union {
+    int i;
+}
+
+%rule %inline op : '+'
+                 | '-'
+                 ;
+
+%%
+
+operation : op?
+          ;
+
+%%
+
+static int yylex(YYSTYPE *yylval, YYLTYPE *loc)
+{
+  return 0;
+}
+
+static int yyerror(YYLTYPE *loc, const char *str)
+{
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+}

spec/lrama/parser_spec.rb

@@ -2676,6 +2676,75 @@
         end
       end
 
+      context "when parameterized rule's arguments include inline" do
+        let(:path) { "inlining/parameterized_args_include_inline.y" }
+
+        it "expands inlining rules" do
+          expect(grammar.nterms.sort_by(&:number)).to match_symbols([
+            Sym.new(id: T::Ident.new(s_value: "$accept"),   alias_name: nil, number: 5, tag: nil, term: false, token_id: 0, nullable: false),
+            Sym.new(id: T::Ident.new(s_value: "option_op"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 1, nullable: true),
+            Sym.new(id: T::Ident.new(s_value: "operation"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 2, nullable: true),
+          ])
+
+          expect(grammar.rules).to eq([
+            Rule.new(
+              id: 0,
+              lhs: grammar.find_symbol_by_s_value!("$accept"),
+              rhs: [
+                grammar.find_symbol_by_s_value!("operation"),
+                grammar.find_symbol_by_s_value!("YYEOF"),
+              ],
+              token_code: nil,
+              nullable: false,
+              precedence_sym: grammar.find_symbol_by_s_value!("YYEOF"),
+              lineno: 21,
+            ),
+            Rule.new(
+              id: 1,
+              lhs: grammar.find_symbol_by_s_value!("option_op"),
+              rhs: [],
+              token_code: nil,
+              nullable: true,
+              precedence_sym: nil,
+              lineno: 21,
+            ),
+            Rule.new(
+              id: 2,
+              lhs: grammar.find_symbol_by_s_value!("option_op"),
+              rhs: [
+                grammar.find_symbol_by_s_value!("'+'"),
+              ],
+              token_code: nil,
+              nullable: false,
+              precedence_sym: grammar.find_symbol_by_s_value!("'+'"),
+              lineno: 21,
+            ),
+            Rule.new(
+              id: 3,
+              lhs: grammar.find_symbol_by_s_value!("option_op"),
+              rhs: [
+                grammar.find_symbol_by_s_value!("'-'"),
+              ],
+              token_code: nil,
+              nullable: false,
+              precedence_sym: grammar.find_symbol_by_s_value!("'-'"),
+              lineno: 21,
+            ),
+            Rule.new(
+              id: 4,
+              lhs: grammar.find_symbol_by_s_value!("operation"),
+              rhs: [
+                grammar.find_symbol_by_s_value!("option_op"),
+              ],
+              token_code: nil,
+              nullable: true,
+              precedence_sym: nil,
+              lineno: 21,
+            ),
+          ])
+        end
+      end
+
       context 'when inline with resolve index `@n` style' do
         let(:path) { "inlining/resolve_index.y" }