Apply Array#push's resizing heuristic to #unshift

[HertzDevil]

Fixes #10748.

The following illustrates some examples of the heuristic in action:

class Array(T)
  def to_s(io : IO) : Nil
    root = root_buffer
    io << '['
    @capacity.times do |i|
      io << ", " if i > 0
      if @offset_to_buffer <= i < @offset_to_buffer + @size
        root[i].inspect(io)
      else
        io << '_'
      end
    end
    io << ']'
  end
end

x = Array(Int32).new(5)
x.push(1, 2); puts x
x.unshift(3); puts x
x.push(4); puts x

# before:
# [1, 2, _, _, _]
# [_, _, _, _, 3, 1, 2, _, _, _]
# [_, _, _, _, 3, 1, 2, 4, _, _]

# after:
# [1, 2, _, _, _]
# [_, 3, 1, 2, _] # there is enough space; move 1 and 2 to the middle of the root buffer
# [_, 3, 1, 2, 4]

x = Array(Int32).new(4)
x.unshift(0); puts x
x.shift; x.unshift(1); puts x
x.shift; x.unshift(2); puts x
x.unshift(4, 3); puts x

# before:
# [_, _, _, 0, _, _, _, _]
# [_, _, _, _, _, _, _, 1, _, _, _, _, _, _, _, _]
# [_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 2, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]
# [_, _, _, _, _, _, _, _, _, _, _, _, _, 4, 3, 2, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]

# after:
# [_, 0, _, _] # there is pre-allocated space; start inserting elements from the middle
# [_, 1, _, _]
# [_, 2, _, _]
# [_, 4, 3, 2] # there is enough space; move 3 and 2 to the middle of the root buffer

[stakach]

LGTM

[stakach]

Hopefully this can make it into v1.0.1

[straight-shoota]

This is probably fine for a quick fix.

But I think it might be beneficial to take a closer look at the applied heuristics. I could see some room for improvement there.
A worst-case scenario with this is adding an element each to the front and back of an array that's filled to capacity (a typical example would be literals). Adding just these two elements quadruples the capacity: it's doubled by both push and unshift, regardless of their order. This means allocating a lot of unnecessary memory.
If the resize operations for push and unshift would not fill the buffer all the way to the front and back, respectively, this could be avoided.
I don't know what would be a better solution and I'm not even sure this needs to be changed, but it probably deserves an evaluation and discussion. Obviously, the best solution depends on a fair balance between different use cases.

[asterite]

I could see some room for improvement there

I see what you did here 😄 😉

[asterite]

We should probably merge this since it's an important fix

[beta-ziliani]

Let's get this for 1.1.0. There's the unanswered question about the need for 10k iterations in tests, when probably a handful ones should suffice. But we can change that later (I'd like to hear @HertzDevil opinion on the matter).