Simplify Enumerable#to_a (#15432)

The implementation of `#to_a` is identical to the yielding variant `#to_a(&)`. We can simply delegate to `#to_a(&)`.
As a bonus, inheriting types which override `#to_a(&)` with an optimized implementation will implicitly use the same optimization for `#to_a` as well. This means we can drop `Indexable#to_a`.

Inheriting types `Tuple` and `Hash` already explicitly delegate `#to_a` to their override implementations of `#to_a(&)`.
We keep these overrides of `#to_a` because they augment the documentation.
But we replace the method bodies with `super` to make it clear that the behaviour is inherited and the `def` only provides documentation.

src/enumerable.cr

@@ -2013,9 +2013,7 @@ module Enumerable(T)
   # (1..5).to_a # => [1, 2, 3, 4, 5]
   # ```
   def to_a : Array(T)
-    ary = [] of T
-    each { |e| ary << e }
-    ary
+    to_a(&.as(T))
   end
 
   # Returns an `Array` with the results of running *block* against each element of the collection.

src/hash.cr

@@ -2083,7 +2083,7 @@ class Hash(K, V)
   #
   # The order of the array follows the order the keys were inserted in the Hash.
   def to_a : Array({K, V})
-    to_a(&.itself)
+    super
   end
 
   # Returns an `Array` with the results of running *block* against tuples with key and values

src/indexable.cr

@@ -693,17 +693,6 @@ module Indexable(T)
     end
   end
 
-  # Returns an `Array` with all the elements in the collection.
-  #
-  # ```
-  # {1, 2, 3}.to_a # => [1, 2, 3]
-  # ```
-  def to_a : Array(T)
-    ary = Array(T).new(size)
-    each { |e| ary << e }
-    ary
-  end
-
   # Returns an `Array` with the results of running *block* against each element of the collection.
   #
   # ```

src/tuple.cr

@@ -545,7 +545,7 @@ struct Tuple
   # {1, 2, 3, 4, 5}.to_a # => [1, 2, 3, 4, 5]
   # ```
   def to_a : Array(Union(*T))
-    to_a(&.as(Union(*T)))
+    super
   end
 
   # Returns an `Array` with the results of running *block* against each element of the tuple.