CUDA: Use relaxed strides checking to compute contiguity - #6830

Since NumPy 1.8, a relaxed strides check has been available for
computing the contiguity of arrays (and the relaxed check is the default
starting from 1.12). The relaxed check permits additional conditions for
arrays to be considered contiguous:

- All 0-size arrays are considered contiguous, even if they are
  multidimensional.
- Strides for an axis are ignored if its shape is 1 when checking
  contiguity.

Examples of shapes and strides that would now be considered contiguous:

- Shape: (1, 10), Strides: (800, 80): because the first axis has size 1.
- Shape: (1, 0, 2), Strides (64, 16, 8): because the second axis has
  size 0.

This commit makes relaxed strides checking the default when computing
the C- and F-contiguity of device arrays, and enables more use cases.
For example, from the reproducer in Issue numba#6824:

```python
import dask.array as da
import numpy as np
from numba import guvectorize

x = da.arange(10000, dtype=np.float64).reshape(100, 100).rechunk((1, 10))
f = np.ascontiguousarray(x.blocks[0, 0])
```

`f` is an array that is only contiguous under relaxed strides checking,
and prior to this commit could not be transferred to a device array.

Since this may expose latent bugs (the switch in NumPy exposed some
issues between versions 1.10.0 and 1.10.2, for example), a config
variable, `NPY_RELAXED_STRIDES_CHECKING` is provided to restore the old,
strict checking. This is provided on a temporary basis in case any bugs
need to be worked out, and will be removed in 0.55 in the current
deprecation schedule.

Fixes numba#6824.
Fixes numba#4943.
Fixes numba#2766.