Set the mruby-1.4.0 release date to `2018-1-16`.

Passed mruby-test on Cygwin.

In mruby, those methods are defined in `Integral` module.

Since mruby mixes `Integer` and `Float`, integer operations have
been moved to `Integral` module.

To distinguish string keys and symbol keys.

Also removed tests that depends on implementation details of the default
`method_missing` behavior.

This information is not mandatory but causes a lot of problems in the
past due to infinite recursion by redefining `to_str`, `inspect` etc.

The receiver can be switched using `#instance_eval` etc.

For example, the following code behaved wrong:

```ruby
Object.instance_exec(1,2,3){|*a|
  def foo
    42
  end
}
p foo()
```

Make source compilable with C++17

Changes applied:

- Removing "register" keyword
- Fixing const pointer to pointer assignments
- Adding type casts to rb_malloc calls

Since it is already set in `mrb_proc_new()`.

Method look-up for `OP_SUPER` should start from the superclass of
the `target_class` but if it fails, the look-up for `method_missing`
should start from the class of the receiver.

The following code explains the case:
```ruby
class Bar
  def foo
    super
  end
end

class Foo<Bar
  def method_missing(mid, *)
    p mid
  end
end
```
Foo.new.foo

Not from `ci->target_class` that may be switched using `class_eval` etc.
fix #3899, fix #3906

We found out there is a mruby specific limitation that `super` may be
screwed up when a method is defined in a module and `super` is called
in the block with the target class switched (for example, `super` in
`class_eval` block).  Now we raise `RuntimeError` for such cases.

The following code works in CRuby but not in mruby.
```
module M
  def foo
    "aaa".singleton_class.class_eval{super 2}
  end
end
class Foo
  def foo(*); end
end
class Bar<Foo
  include M
end
Bar.new.foo
```

Add mruby-method

Implement IO#initialize_copy