Refactor the way ndarray methods are implemented

Currently routines implementations that have interfaces both as a module-level function and as a `ndarray` method (e.g. `cupy.std` and `ndarray.std`) are implemented in such a way that the main code is implemented in the `ndarray` method and it is called by the module-level counterpart.

I think it's better to reverse it, so that `ndarray` method calls the other.

Benefits:
* Simplifies `core.pyx` where `ndarray` is defind.
* Reduced cython module dependencies: I think it does not make sense for `core.pyx` to have a dependency to `_routines_statistics.pyx`.
* Reduced cython compilation because they can be implemented in `.py`. We can still choose to keep performance-critical functions (if any) in Cython code.

**(edit)** Originally wrote `sort` as an example but it was not a good example because `ndarray.sort` behaves in in-place manner in contrast to `cupy.sort`.

Start by comparing the implementations of cupy.std and ndarray.std, then inspect core.pyx and _routines_statistics.pyx to understand the current dependency. Check which other routines expose both interfaces and whether sort is excluded because its methods differ in-place behavior. Done means the chosen methods delegate in the proposed direction without changing their behavior.

Written by the indexing model from the issue text.