Support generic types in crystal tool hierarchy

[HertzDevil]

Right now, the hierarchy tool does not support generic types, in that it simply prints those types' instance variables themselves again instead of their types and sizes:

$ bin/crystal tool hierarchy src/prelude.cr -e "^(Array|Slice)$"
- class Object (4 bytes)
  |
  +- class Reference (4 bytes)
  |  |
  |  +- class Array(T)
  |         @size             : @size
  |         @capacity         : @capacity
  |         @offset_to_buffer : @offset_to_buffer
  |         @buffer           : @buffer
  |
  +- struct Value (0 bytes)
     |
     +- struct Struct (0 bytes)
        |
        +- struct Slice(T)
               @size      : @size
               @read_only : @read_only
               @pointer   : @pointer

This PR adds support for those members by ensuring that the byte sizes are queried only when they are independent of any unbound type parameters, most notably instances of Pointer and Proc:

class Array(T) (24 bytes)
    @size             : Int32      (4 bytes)
    @capacity         : Int32      (4 bytes)
    @offset_to_buffer : Int32      (4 bytes)
    @buffer           : Pointer(T) (8 bytes)

struct Slice(T) (16 bytes)
    @size      : Int32      (4 bytes)
    @read_only : Bool       (1 bytes)
    @pointer   : Pointer(T) (8 bytes)

In this case, all of Array and Slice's members have constant sizes, so their total sizes are also shown.

When used as an instance variable, Array has a fixed size regardless of its members, because Array is a reference:

class Indexable::CombinationIterator(A, T) (64 bytes)
    @size    : Int32            (4 bytes)
    @n       : Int32            (4 bytes)
    @copy    : Array(T)         (8 bytes)
    @pool    : Array(T)         (8 bytes)
    @indices : Array(Int32)     (8 bytes)
    @stop    : Bool             (1 bytes)
    @i       : Int32            (4 bytes)
    @first   : Bool             (1 bytes)
    @reuse   : (Array(T) | Nil) (8 bytes)

For structs, an example of a constant-size generic type being used generically is Set:

struct Set(T) (8 bytes)
    @hash : Hash(T, Nil) (8 bytes)

struct Iterator::UniqIterator(I, T, U)
    @iterator : I
    @func     : Proc(T, U) (16 bytes)
    @set      : Set(U)     ( 8 bytes)

Here Iterator::UniqIterator does not have a constant size because @iterator's size can change depending on I.

[beta-ziliani]

🚀