- Remove ` kh_put_prepare` function used only internally
- Remove `n_occupied` member from `kh_` struct

`puts` should print newline when called without arguments.

Update document for `ObjectSpace.memsize_of` [ci skip]

The `recurse` keyword is removed by f00657ea.

Use type tag for hash code in `ht_hash_func()`

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.

Improve `mruby-os-memsize`

If it qualify a return type that is not a pointer with `const`, the
compiler ignores it.

And, in the calculation of the instance variable size, the fraction was
always rounded down because of division of integers, so fix it.

At the same time, test items that are no longer passed due to this
change are deleted.

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.

The `ObjectSpace#memsize_of` and `ObjectSpace#memsize_of_all` in `mruby-objectspace` ware
migrated to `mruby-os-memsize` mrbgem.

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).