Define consistent nodata propagation for interp_points and allow to return interpolator

[rhugonnet]

Most of the line changes in this PR are due to re-structuring, moving out functions of the Raster class (see #539, in preparation for #383) into their own module, here only those linked to interp_points.

This PR also adds a nodata propagation scheme (as scipy.interpolate.interpn does not support nodata propagation natively except for methods "nearest" and "linear") and allows to return an interpolator that contains this nodata propagation (to optimize speed of iterative methods calling the same interpolator several times, such as DEM coregistration).

It turned out that interpolation of map_coordinates with splines of order 3/5 does not match "cubic" or "quintic" in interpn, only order 0/1 do match for "nearest" and "linear", so all other are dropped. The nodata propagation and accuracy of results for values near the edge of NaNs is now tested thoroughly! 😄

Resolves #559
Starts addressing #539 for functions related to interp_points

TO-DO:

• Add tests on return_interpolator,
• Add tests validating that the interpolator generated produces exactly the same results as interpn,
• Add distance of nodata spreading as an argument,
• Enforce the same NaN propagation between map_coordinates and interpn.

[rhugonnet]

This PR is finalized, and ready for review! 😄 @adehecq @erikmannerfelt @atedstone
Important: don't lose time looking at changes from functions moved from raster.py to georeferencing.py, etc... This is simply restructuring linked to #539, which was necessary to have functionalities separate from the Raster class (to avoid always re-building a Raster object for performance, for instance in coregistration), and will facilitate building the Xarray accessor as well.
All the core changes are in interpolate.py and test_interpolate.py.

We now have a fully consistent point interpolation with all benefits and (normally) none of the limitations of existing implementations:

• Very fast on an equal grid (by relying on scipy.ndimage.map_coordinates) which supports "nearest" or "linear" methods,
• Otherwise (for a regular grid, or other interpolation methods), it relies on the equivalent of scipy.interpolate.interpn but coded as an interpolator function based on SciPy's code (so that it can be constructed only once and used iteratively, to greatly improve performance for instance in coregistration),
• Supports modular NaN propagation for all methods by adding our own consistent NaN propagation scheme on top of SciPy (that barely supports any NaN propagation in interpolation, only "nearest" and "linear" do in interpn and inconsistently with map_coordinates), with our default method tested for its high accuracy (propagate NaNs for as many pixels as half the method order rounded up: 1 for linear, 2 for cubic, 3 for quintic).

All the tests allow to check the robustness of the implementation:

• Exact same results for interpn and map_coordinates, and the interpolator optionally returned,
• Exact same NaN propagation,
• High accuracy of interpolation near NaN edges (10e-4 relative) for the default NaN propagation.

[adehecq]

I have a few comments, but otherwise looking good to me!
Thanks! 🙌