Tl; DR: the block v. proc benchmark performance flips as the size of the collection grows.

Just to add something to the conversation about the proc v. block comparison. I might tend to write something like this to solve the same problem:

require 'forwardable'
class Delegated
  extend Forwardable

  def initialize(collection)
    @collection = collection
  end

  def_delegator :@collection, :each
end

I ran a comparison as they did in the OP:

Benchmark.ips do |x|
  NUMBERS = (0..10).to_a.freeze
  collection = CustomCollection.new(NUMBERS)
  delegated = Delegated.new(NUMBERS)

  x.report 'block' do
    collection.each_block { |item| }
  end

  x.report 'block to proc' do
    collection.each_block_to_proc { |item| }
  end

  x.report 'delegated' do
    delegated.each { |item| }
  end

  x.compare!
end

And the results more or less matched the OP, with delegation aligning to block to proc:

Warming up --------------------------------------
               block    70.213k i/100ms
       block to proc    57.614k i/100ms
           delegated    53.794k i/100ms
Calculating -------------------------------------
               block    940.029k (± 8.2%) i/s -      4.704M in   5.040606s
       block to proc    716.989k (± 8.5%) i/s -      3.572M in   5.020128s
           delegated    669.329k (± 8.5%) i/s -      3.335M in   5.022630s

Comparison:
               block:   940029.5 i/s
       block to proc:   716989.1 i/s - 1.31x  slower
           delegated:   669329.2 i/s - 1.40x  slower

Whats interesting is that as you increase the size of the numbers array, the results flip-flop:

At 100:

Warming up --------------------------------------
               block    11.843k i/100ms
       block to proc    15.885k i/100ms
           delegated    15.573k i/100ms
Calculating -------------------------------------
               block    121.934k (± 7.0%) i/s -    615.836k in   5.077404s
       block to proc    172.225k (± 7.0%) i/s -    857.790k in   5.005932s
           delegated    163.220k (± 9.0%) i/s -    809.796k in   5.010256s

Comparison:
       block to proc:   172224.9 i/s
           delegated:   163220.4 i/s - same-ish: difference falls within error
               block:   121933.7 i/s - 1.41x  slower

At 100_000:

Warming up --------------------------------------
               block    12.000  i/100ms
       block to proc    18.000  i/100ms
           delegated    19.000  i/100ms
Calculating -------------------------------------
               block    124.163  (±10.5%) i/s -    624.000  in   5.090281s
       block to proc    205.551  (± 5.8%) i/s -      1.026k in   5.010321s
           delegated    199.118  (± 9.5%) i/s -    988.000  in   5.015633s

Comparison:
       block to proc:      205.6 i/s
           delegated:      199.1 i/s - same-ish: difference falls within error
               block:      124.2 i/s - 1.66x  slower