Improve perf when building Ruby arrays from Rust

Applies Mat's suggestion from #169, essentially using RArray's
FromIterator implementation which appends to the RArray in batch instead
of `push`ing in a loop.

Before:
```
Call host func (4 args):   296182.4 i/s
Call host func (16 args):   239771.2 i/s - 1.24x  slower
Call host func (64 args):   105414.9 i/s - 2.81x  slower
Call host func (128 args):    44266.8 i/s - 6.69x  slower
Call host func (256 args):    13739.3 i/s - 21.56x  slower
```

After:
```
Call host func (4 args):   302802.0 i/s
Call host func (16 args):   250214.7 i/s - 1.21x  slower
Call host func (64 args):   114372.2 i/s - 2.65x  slower
Call host func (128 args):    47095.3 i/s - 6.43x  slower
Call host func (256 args):    14555.6 i/s - 20.80x  slower
```

Closes #169

Author: jbourassa

ext/src/ruby_api/func.rs

@@ -222,13 +222,11 @@ impl<'a> Func<'a> {
         match results.as_slice() {
             [] => Ok(().into_value()),
             [result] => result.to_ruby_value(store),
-            _ => {
-                let array = RArray::with_capacity(results.len());
-                for result in results {
-                    array.push(result.to_ruby_value(store)?)?;
-                }
-                Ok(array.as_value())
-            }
+            _ => results
+                .into_iter()
+                .map(|result| result.to_ruby_value(store))
+                .collect::<Result<RArray, _>>()
+                .map(|ary| ary.as_value()),
         }
     }
 }
@@ -270,15 +268,15 @@ pub fn make_func_closure(
         let wrapped_caller = Obj::wrap(Caller::new(caller_impl));
         let store_context = StoreContextValue::from(wrapped_caller);
 
-        let rparams = RArray::with_capacity(params.len() + 1);
-        rparams.push(wrapped_caller.as_value()).unwrap();
-
-        for (i, param) in params.iter().enumerate() {
-            let rparam = param
+        let params_iter = params.iter().enumerate().map(|(i, param)| {
+            param
                 .to_ruby_value(&store_context)
-                .map_err(|e| wasmtime::Error::msg(format!("invalid argument at index {i}: {e}")))?;
-            rparams.push(rparam).unwrap();
-        }
+                .map_err(|e| wasmtime::Error::msg(format!("invalid argument at index {i}: {e}")))
+        });
+
+        let rparams = std::iter::once(Ok(wrapped_caller.as_value()))
+            .chain(params_iter)
+            .collect::<Result<RArray, _>>()?;
 
         let ruby = Ruby::get().unwrap();
         let callable = ruby.get_inner(callable);