The function corresponding to `ht_hash_func()` was as follows in the days of
khash implementation (before d78acc7a).

  ```c
  mrb_hash_ht_hash_func(mrb_state *mrb, mrb_value key)
  {
    enum mrb_vtype t = mrb_type(key);
    ...
    switch (t) {
    ...
    default:
      hv = mrb_funcall(mrb, key, "hash", 0);
      h = (khint_t)t ^ (khint_t)mrb_fixnum(hv);
      break;
    }
    ...
  }
  ```

When switched to the segmented list implementation (d78acc7a), this function
was changed as follows.

  ```c
  sg_hash_func(mrb_state *mrb, seglist *t, mrb_value key)
  {
    enum mrb_vtype tt = mrb_type(key);
    ...
    switch (tt) {
    ...
    default:
      hv = mrb_funcall(mrb, key, "hash", 0);
      h = (size_t)t ^ (size_t)mrb_fixnum(hv);
      break;
    }
    ...
  }
  ```

Since the argument `t` was added, the variable for type tag was changed from
`t` to `tt`, but the variable used in the expression of `h` remained `t`.

Probably this is an omission of change, so fixed it.

It happens when a hash made empty calls `rehash`.

To make debugging easy, and to improve the performance little bit.

The responsibility moved to caller to avoid confusion. Currently the
function is called from only 2 places, so it is relatively easy to
ensure not to update `gray_list` in the caller.  But the assumption
may change in the future.

`mrb_ary_modify` calls `mrb_write_barrier`, so can cause the same
problem of the past `push`. It is provided for use-level API.

When the array is very big, the simpler `mrb_write_barrier` causes
calling `gc_mark_children` for big arrays repeatedly. That would hinder
performance very badly.

Extract memsize to gem

Those methods are originally CRuby specific.
Co-authored-by: Yukihiro "Matz" Matsumoto <matz@ruby.or.jp>

Those tests succeeds only on some configuration.

The old code compiles only on `MRB_NO_BOXING`.

`mrb_value` may or may not be struct according to configuration.

`C` retrieves a `mrb_value` that refers a class/module.
`c` retrieves a `struct RClass*` pointer to a class/module.

`ObjectSpace.memsize_of_all` takes a class and count memory size of all
instances of the class and its subclasses (if any).

Add ObjectSpace.memsize_of_all

This bug has been there since mruby 1.4.0 (2018-04).

Also avoid `mrb_funcall` to minimize VM recursion.

Memory size of a Fiber is calculated by stack size only in CRuby.

This is enhancement from CRuby's `memsize_of`. We need to change the
CRuby first for the enhancement.