MAINT: move things in numeric.pyi to the top-level __init__.pyi (#50)

In gh-38 some stubs were added for `core/numeric.py`. The problem is
that these stubs are not picked up at all, as can be tested with

```python
import numpy as np

reveal_type(np.ones_like)
```

which on master gives

```
Revealed type is 'Any'
```

The issue is that the NumPy main repo importing from numeric doesn't
automatically mean the type stubs do. We could add the relevant
imports on the stubs level too, but there is no need for the structure
of the stubs to mimic the structure of NumPy unless they are being
used to type-check NumPy itself (which we aren't doing yet), and
indeed having them mimic the internal structure just causes extra pain
of trying to keep up with internal refactors that don't affect the
public API. In fact, we already ignore NumPy's internal structure by
defining `ndarray` in the top-level `__init__.pyi`, when it is
actually exported by `numeric.py`.

So instead, just fix the issue by moving the numeric stubs into the
top level `__init__.pyi` (plus some minor bug fixes). On master the
above script now correctly gives:

```
Revealed type is 'def [_ArrayLike] (a: _ArrayLike`-1, dtype: Union[numpy.dtype, None] =, order: builtins.str =, subok: builtins.bool =, shape: Union[builtins.int, typing.Sequence[builtins.int], None] =) -> numpy.ndarray
````

Author: person142

numpy-stubs/__init__.pyi

@@ -7,6 +7,7 @@ from typing import (
     Any,
     ByteString,
     Container,
+    Callable,
     Dict,
     IO,
     Iterable,
@@ -485,6 +486,90 @@ def zeros(
 def ones(
     shape: _ShapeLike, dtype: _DtypeLike = ..., order: Optional[str] = ...
 ) -> ndarray: ...
+def zeros_like(
+    a: _ArrayLike,
+    dtype: Optional[dtype] = ...,
+    order: str = ...,
+    subok: bool = ...,
+    shape: Optional[Union[int, Sequence[int]]] = ...,
+) -> ndarray: ...
+def ones_like(
+    a: _ArrayLike,
+    dtype: Optional[dtype] = ...,
+    order: str = ...,
+    subok: bool = ...,
+    shape: Optional[_ShapeLike] = ...,
+) -> ndarray[int]: ...
+def full(
+    shape: _ShapeLike, fill_value: Any, dtype: Optional[dtype] = ..., order: str = ...
+) -> ndarray: ...
+def full_like(
+    a: _ArrayLike,
+    fill_value: Any,
+    dtype: Optional[dtype] = ...,
+    order: str = ...,
+    subok: bool = ...,
+    shape: Optional[_ShapeLike] = ...,
+) -> ndarray: ...
+def count_nonzero(
+    a: _ArrayLike, axis: Optional[Union[int, Tuple[int], Tuple[int, int]]] = ...
+) -> Union[int, ndarray]: ...
+def isfortran(a: ndarray) -> bool: ...
+def argwhere(a: _ArrayLike) -> ndarray: ...
+def flatnonzero(a: _ArrayLike) -> ndarray: ...
+def correlate(a: _ArrayLike, v: _ArrayLike, mode: str = ...) -> ndarray: ...
+def convolve(a: _ArrayLike, v: _ArrayLike, mode: str = ...) -> ndarray: ...
+def outer(a: _ArrayLike, b: _ArrayLike, out: ndarray = ...) -> ndarray: ...
+def tensordot(
+    a: _ArrayLike,
+    b: _ArrayLike,
+    axes: Union[
+        int, Tuple[int, int], Tuple[Tuple[int, int], ...], Tuple[List[int, int], ...]
+    ] = ...,
+) -> ndarray: ...
+def roll(
+    a: _ArrayLike,
+    shift: Union[int, Tuple[int, ...]],
+    axis: Optional[Union[int, Tuple[int, ...]]] = ...,
+) -> ndarray: ...
+def rollaxis(a: _ArrayLike, axis: int, start: int = ...) -> ndarray: ...
+def moveaxis(
+    a: ndarray,
+    source: Union[int, Sequence[int]],
+    destination: Union[int, Sequence[int]],
+) -> ndarray: ...
+def cross(
+    a: _ArrayLike,
+    b: _ArrayLike,
+    axisa: int = ...,
+    axisb: int = ...,
+    axisc: int = ...,
+    axis: Optional[int] = ...,
+) -> ndarray: ...
+def indices(
+    dimensions: Sequence[int], dtype: dtype = ..., sparse: bool = ...
+) -> Union[ndarray, Tuple[ndarray, ...]]: ...
+def fromfunction(function: Callable, shape: Tuple[int, int], **kwargs) -> Any: ...
+def isscalar(element: Any) -> bool: ...
+def binary_repr(num: int, width: Optional[int] = ...) -> str: ...
+def base_repr(number: int, base: int = ..., padding: int = ...) -> str: ...
+def identity(n: int, dtype: Optional[dtype] = ...) -> ndarray: ...
+def allclose(
+    a: _ArrayLike,
+    b: _ArrayLike,
+    rtol: float = ...,
+    atol: float = ...,
+    equal_nan: bool = ...,
+) -> bool: ...
+def isclose(
+    a: _ArrayLike,
+    b: _ArrayLike,
+    rtol: float = ...,
+    atol: float = ...,
+    equal_nan: bool = ...,
+) -> Union[bool_, ndarray]: ...
+def array_equal(a1: _ArrayLike, a2: _ArrayLike) -> bool: ...
+def array_equiv(a1: _ArrayLike, a2: _ArrayLike) -> bool: ...
 
 # TODO(shoyer): remove when the full numpy namespace is defined
 def __getattr__(name: str) -> Any: ...