Add capacity growth to RocStr

Also, cleans up the alloc and realloc api for both list and str.
Updates Str.reserve to match List.reserve

crates/compiler/builtins/bitcode/src/utils.zig

@@ -213,6 +213,53 @@ inline fn decref_ptr_to_refcount(
     }
 }
 
+// We follow roughly the [fbvector](https://github.com/facebook/folly/blob/main/folly/docs/FBVector.md) when it comes to growing a RocList.
+// Here is [their growth strategy](https://github.com/facebook/folly/blob/3e0525988fd444201b19b76b390a5927c15cb697/folly/FBVector.h#L1128) for push_back:
+//
+// (1) initial size
+//     Instead of growing to size 1 from empty, fbvector allocates at least
+//     64 bytes. You may still use reserve to reserve a lesser amount of
+//     memory.
+// (2) 1.5x
+//     For medium-sized vectors, the growth strategy is 1.5x. See the docs
+//     for details.
+//     This does not apply to very small or very large fbvectors. This is a
+//     heuristic.
+//
+// In our case, we exposed allocate and reallocate, which will use a smart growth stategy.
+// We also expose allocateExact and reallocateExact for case where a specific number of elements is requested.
+
+// calculateCapacity should only be called in cases the list will be growing.
+// requested_length should always be greater than old_capacity.
+pub inline fn calculateCapacity(
+    old_capacity: usize,
+    requested_length: usize,
+    element_width: usize,
+) usize {
+    // TODO: there are two adjustments that would likely lead to better results for Roc.
+    // 1. Deal with the fact we allocate an extra u64 for refcount.
+    //    This may lead to allocating page size + 8 bytes.
+    //    That could mean allocating an entire page for 8 bytes of data which isn't great.
+    // 2. Deal with the fact that we can request more than 1 element at a time.
+    //    fbvector assumes just appending 1 element at a time when using this algorithm.
+    //    As such, they will generally grow in a way that should better match certain memory multiple.
+    //    This is also the normal case for roc, but we could also grow by a much larger amount.
+    //    We may want to round to multiples of 2 or something similar.
+    var new_capacity: usize = 0;
+    if (element_width == 0) {
+        return requested_length;
+    } else if (old_capacity == 0) {
+        new_capacity = 64 / element_width;
+    } else if (old_capacity < 4096 / element_width) {
+        new_capacity = old_capacity * 2;
+    } else if (old_capacity > 4096 * 32 / element_width) {
+        new_capacity = old_capacity * 2;
+    } else {
+        new_capacity = (old_capacity * 3 + 1) / 2;
+    }
+    return @maximum(new_capacity, requested_length);
+}
+
 pub fn allocateWithRefcountC(
     data_bytes: usize,
     element_alignment: u32,