GH-48481: [Ruby] Correctly infer types for nested integer arrays (#48699)

### Rationale for this change

When building an `Arrow::Table` from a Ruby Hash passed to `Arrow::Table.new`, nested Integer arrays are incorrectly inferred as `list<uint8>` or `list<int8>` regardless of the actual values contained. Nested integer arrays should be correctly inferred as the appropriate list type (e.g., `list<int64>`, `list<uint64>`) based on their values, similar to how flat arrays are handled, unless they contain values out of range for any integer type.

### What changes are included in this PR?

This PR modifies the logic in `detect_builder_info()` to fix the inference issue. Specifically:

- **Persist `sub_builder_info` across sub-array elements**: Previously, `sub_builder_info` was recreated for each sub-array element in the Array. The logic has been updated to accumulate and carry over the builder information across elements to ensure correct type inference for the entire list.
- **Refactor Integer builder logic**: Following the pattern used for `BigDecimal`, the logic for determining the Integer builder has been moved to `create_builder()`. `detect_builder_info()` now calls this function.

**Note:** 

- As a side effect of this refactoring, nested lists of `BigDecimal` (which were previously inferred as `string`) may now have their types inferred. However, comprehensive testing and verification for nested `BigDecimal` support will be addressed in a separate issue to keep this PR focused.
- We stopped using `IntArrayBuilder` for inference logic to ensure correctness. This results in a performance overhead (array building is approximately 2x slower) as we can no longer rely on the specialized builder's detection.

```text
                                           user     system      total        real
    array_builder int32 100000         0.085867   0.000194   0.086061 (  0.086369)
int_array_builder int32 100000         0.042163   0.001033   0.043196 (  0.043268)
    array_builder int64 100000         0.086799   0.000015   0.086814 (  0.086828)
int_array_builder int64 100000         0.044493   0.000973   0.045466 (  0.045469)
    array_builder uint32 100000        0.085748   0.000009   0.085757 (  0.085768)
int_array_builder uint32 100000        0.044463   0.001034   0.045497 (  0.045498)
    array_builder uint64 100000        0.084548   0.000987   0.085535 (  0.085537)
int_array_builder uint64 100000        0.044206   0.000017   0.044223 (  0.044225)
```

### Are these changes tested?

Yes. `ruby ruby/red-arrow/test/run-test.rb`

### Are there any user-facing changes?

Yes.

* GitHub Issue: #48481

Authored-by: hypsakata <[email protected]>
Signed-off-by: Sutou Kouhei <[email protected]>

Author: hypsakata

ruby/red-arrow/lib/arrow/array-builder.rb

@@ -74,14 +74,23 @@ def detect_builder_info(value, builder_info)
             detected: true,
           }
         when Integer
-          if value < 0
+          builder_info ||= {}
+          min = builder_info[:min] || value
+          max = builder_info[:max] || value
+          min = value if value < min
+          max = value if value > max
+
+          if builder_info[:builder_type] == :int || value < 0
             {
-              builder: IntArrayBuilder.new,
-              detected: true,
+              builder_type: :int,
+              min: min,
+              max: max,
             }
           else
             {
-              builder: UIntArrayBuilder.new,
+              builder_type: :uint,
+              min: min,
+              max: max,
             }
           end
         when Time
@@ -150,18 +159,19 @@ def detect_builder_info(value, builder_info)
             end
           end
         when ::Array
-          sub_builder_info = nil
+          sub_builder_info = builder_info && builder_info[:value_builder_info]
           value.each do |sub_value|
             sub_builder_info = detect_builder_info(sub_value, sub_builder_info)
             break if sub_builder_info and sub_builder_info[:detected]
           end
           if sub_builder_info
-            sub_builder = sub_builder_info[:builder]
-            return builder_info unless sub_builder
+            sub_builder = sub_builder_info[:builder] || create_builder(sub_builder_info)
+            return sub_builder_info unless sub_builder
             sub_value_data_type = sub_builder.value_data_type
             field = Field.new("item", sub_value_data_type)
             {
               builder: ListArrayBuilder.new(ListDataType.new(field)),
+              value_builder_info: sub_builder_info,
               detected: sub_builder_info[:detected],
             }
           else
@@ -186,6 +196,35 @@ def create_builder(builder_info)
           data_type = Decimal256DataType.new(builder_info[:precision],
                                              builder_info[:scale])
           Decimal256ArrayBuilder.new(data_type)
+        when :int
+          min = builder_info[:min]
+          max = builder_info[:max]
+
+          if GLib::MININT8 <= min && max <= GLib::MAXINT8
+            Int8ArrayBuilder.new
+          elsif GLib::MININT16 <= min && max <= GLib::MAXINT16
+            Int16ArrayBuilder.new
+          elsif GLib::MININT32 <= min && max <= GLib::MAXINT32
+            Int32ArrayBuilder.new
+          elsif GLib::MININT64 <= min && max <= GLib::MAXINT64
+            Int64ArrayBuilder.new
+          else
+            StringArrayBuilder.new
+          end
+        when :uint
+          max = builder_info[:max]
+
+          if max <= GLib::MAXUINT8
+            UInt8ArrayBuilder.new
+          elsif max <= GLib::MAXUINT16
+            UInt16ArrayBuilder.new
+          elsif max <= GLib::MAXUINT32
+            UInt32ArrayBuilder.new
+          elsif max <= GLib::MAXUINT64
+            UInt64ArrayBuilder.new
+          else
+            StringArrayBuilder.new
+          end
         else
           nil
         end