New Python iterator approach: vectorise without dtype

Have a look only at the last two commit, as this is a continuation of another PR.

To give it a spin:

    import erfa.nditer as erfa
    
    import numpy as np
    
    pnat = np.zeros([2,3], dtype=np.double)
    v = np.zeros([5,1,3], dtype=np.double)
    s = 1.0
    bm1 = np.sqrt(1.0-0.1**2)
    
    pnat[:,0] = 1.0
    v[:,:,1] = 0.01
    
    print(pnat)
    print(v)
    print(s)
    print(bm1)
    
    ppr = erfa.ab(pnat, v, s, bm1)
    
    print(ppr)

The only tricky part in the implementation is that `NpyIter` is not exposed in `numpy.pxd`. This requires the use of private `NpyIter_GetDataPtrArray()` from `numpy/arrayobject.h`. This implementation is inspired from https://github.com/rainwoodman/chealpy/blob/master/chealpy/npyiter.pxd

It could be further improved by including the output parameter `ppr` in the iterator itself. This would save indexation time, after the call to `eraAb`...
In principal it should be basically the same because `GetNpyIter` is just an accessor that changes the type.  
But I just tried it now like this:
```
    cdef char** dataptrarray = GetDataPtrArray(GetNpyIter(it))
    cdef IterNextFunc iternext = GetIterNext(GetNpyIter(it), NULL)
    cdef NpyIter* ititer = GetNpyIter(it)
    cdef int status = 1
    while status:
        pnat_ = (<double *>(dataptrarray[0]))
        v_    = (<double *>(dataptrarray[1]))
        s_    = (<double *>(dataptrarray[2]))[0]
        bm1_  = (<double *>(dataptrarray[3]))[0]
        ppr_  = (<double *>(dataptrarray[4]))
        eraAb(pnat_, v_, s_, bm1_, ppr_)
        status = iternext(ititer)
```
And I got an ~ 2% speedup on a 5000-element array.  So quite small, but it does seem to help.

Unless there's some possibility the `iter` pointer changes during iteration?