This work mostly consists of:
- a C++ implementation of the ISO-19111:2018 / OGC Topic 2
  "Referencing by coordinates" classes to represent Datums,
  Coordinate systems, CRSs (Coordinate Reference Systems) and
  Coordinate Operations.
- methods to convert between this C++ modeling and WKT1, WKT2
  and PROJ string representations of those objects
- management and query of a SQLite3 database of CRS and Coordinate Operation definition
- a C API binding part of those capabilities

This is all-in-one squashed commit of the work of
https://github.com/OSGeo/proj.4/pull/1040

With projects.h not being available to outside users anymore we need to
define PJ_UNITS, PJ_ELLPS, PJ_PRIME_MERIDIANS and PJ_OPERATIONS
elsewhere.

Related pj_get_*_ref() functions have been removed in favour
of their proj_ namespaced counterparts.

char pointers have been changed to const char pointers.

Resolves #983
Resolved #1147

Make char pointers const

Bletch, pj_init also decodes the to_meters field of pj_unit, but only
handles plain numbers or 1/nnn, but not 1./nnn or mmm/nnn.  (So the
original code would have not decoded the us-in entry properly.)

Probably pj_init should be changed to use the factor field instead.

Alternatively pj_init should look for a "/" anywhere in the field and
decode the numerator and denominator as separate doubles.  This would
be needed if ratios are ever to be entered directly by the user (this
is the strategy used by GeographicLib).  And then, of course, the
functionality should be provided by a separate utility function.

Previously, unit conversion using atof(unit_list[i].to_meter) which
gives the wrong answer with, e.g., "1/10".  Now it directly uses
unit_list[i].factor (e.g., 0.1).

Also fix all the conversion factors for the US Surveyor units so that
they are the closest doubles.  E.g., the conversion factors for US
feet are

        factor              rel error
    old 0.304800609601219   6e-16
        12/39.37            1e-16  
    now 1200/3937.0         5e-17

Maybe someone should check the Indian units (but it's possible that
India and Pakistan have different standards).

* Avoid using angle brackets for PROJ headers.

Switching from #include <proj.h> to #include "proj.h",
and correspondingly for projects.h and proj_api.h,
reduces the risk of accidentally picking up a system
installed older version of the header while building
a new version of PROJ.

* Also handle geodesic.h

Having non-const variables of static lifetime or even global scope is
usually a bad idea. These variables are inherently constants, and this
should be enforced.

This required marking some functions as not modifying input parameters
and marking some pointers as pointers to const.

One advantage is that the compiler usually puts const static variables
in a read-only code segment, so they can't be modified physically.
This can be verified with `nm` (on POSIX systems).

To avoid changes to the public API, functions returning non-const
pointers to data tables were left intact, but the returned data may not
be modified. Internally we prefer using the proj_list_* functions over
the pj_get_*_ref functions, because the former return const pointers.

A pseudo-projection that can be used to convert units of input and
output data. Primarily useful in pipelines.

Unit conversion is performed by means of a pivot unit. The pivot unit
for distance units are the meter and for time we use the modified julian
date. A time unit conversion is performed like

    Unit A -> Modified Julian date -> Unit B

distance units are converted in the same manner, with meter being the
central unit.

The modified Julian date is chosen as the pivout unit since it has a
fairly high precision, goes sufficiently long backwards in time, has no
danger of hitting the upper limit in the near future and it is a fairly
common time unit in astronomy and geodesy. Note that we are using the
Julian date and not day. The difference being that the latter is defined
as an integer and is thus limited to days in resolution. This approach
has been extended wherever it makes sense, e.g. the GPS week unit also
has a fractional part that makes it possible to determine the day, hour
and minute of an observation.

In- and output units are controlled with the parameters

    +xy_in, +xy_out, +z_in, +z_out, +t_in and +t_out

where xy denotes horizontal units, z vertical units and t time units.

Distance units are converted similar to what is already in use in PROJ.4.
To ease usage of the already defined conversion factors a new column
with the factors defined as doubles has been added to the pj_units array.
This simplifies the code significantly, since parsing the defined strings
can be avoided.