Invert order of dummy arguments of procedure `read_grid`.

Specify whether to read shapefile `extr_proj` in procedure `shpc_open`
instead of just trying to read this shapefile. Use `uniform_lon_lat`
to decide whether to read the shapefile. As `shpc_open` is called in
both programs `inst_eddies` and `eddy_graph`, we cannot access
variable `uniform_lon_lat` of module `input_ssh_m`, which is not used
in program `eddy_graph`, nor variable `uniform_lon_lat` of module
`read_grid_m`, which is not used in program `inst_eddies`. So we add a
dummy argument `with_proj` to procedure `shpc_open`.

copy was undefined. The bug came from commit 7f24341b.

Assume that a slice is in a directory
"{shpc_dir}/{orientation}/Slice_{slice}" where shpc_dir can be any
name, orientation is "Anticyclones" or "Cyclones" and slice is an
integer. Do not read or create any longer a file "orientation.txt" in
the slice directory. Add procedure `get_slice_dir`. Add dummy
arguments cyclone and slice to procedure `shpc_open`. Add dummy
argument slice to procedure `shpc_create`.

Rename procedure `write_snapshot` to `save_snapshot`.

Split derived type `shpc_slice_handler` into `shpc_slice_handler` and
`shpc_slice_meta out`. Do not mix what is necessary to open, create
and close, analogous to a logical unit, with what comes from reading
the files.

Create component `unit` for `ishape_last.txt` in derived type
`shpc_slice_handler`. Open, create and close `ishape_last.txt` at the
same time we open, create and close the shapefiles. So we use
`read_opcol` instead of `read_column` when we need to read
`ishape_last.txt`.

We are more clearly separating opening files and reading from them.

Since `NR_util` has been integrated into Jumble.

But reading from them is not here yet.

Since `shpc_open` is called by all processes, reading d0 and
`ishape_last` in `shpc_open` implies that we do not broadcast d0 and
`ishape_last`.

Since processes need d0 to allocate `ishape_last`.

Store `ishape_last` and first date in components of derived type
shpc. We then remove arguments `d_init` and `ishape_last` of procedures
`read_snapshot` and `get_snapshot`.

It was confusing to mix opening an SHPC with broadcasting some part of
the resulting shpc variable.

Note that we then have to declare `d_init` before `ishape_last` in
procedure `get_snapshot`.

Before reading `ishape_last`, because we are going to use `d_init` as
lower bound of `ishape_last`.

We are reverting commit e48b7f7e. I think I did not really appreciate
then that the number of days since 1950-1-1 is another date index. It
is clearer to use just one date index, which is in the dbf files. So,
in effect, we replace everywhere the old 0-based date index k by `k -
d_init`. Note that we no longer need argument `d_init` for procedure
`dispatch_snapshot` and we no longer need to write `d_init` to file
`node_id_param.json`. Note also that the value of every node index
changes by the amount `d_init * e_overestim`.

Because now there is a case when we want to open in appending mode: in
program `inst_eddies`.

Follow-up to commit 3b68dd5.

To ease use of call with keywords.

Rename triplet to collection, `shp_tr` to shpc, shpt to shpc in
comments, identifiers and file names.

Instead of asking the user to define it. So ne no longer need the file
`read_snapshot_nml.txt` for programs `test_read_snapshot` and
`test_send_recv`: we can just supply the remaining data in the `input`
key of tests `Read_snapshot` and `Send_recv`.

Also split the tests, Fortran source files, Python files and JSon
files. Keep at the top level the files used in both `Inst_eddies` and
Overlap.

Motivations for the split:

- The top directory contained many files.

- It may be useful to compile only one of the two sub-projects. For
example, only `Inst_eddies` on Ciclad, where MPI 3 is not available.

Rename files and identifiers: change `"shp_triplet"` to `"shp_tr"`.

Add dummy argument `shp_triplet_dir` to procedure
`shp_triplet_create`. Motivation: program `eddy_graph` needs to create
one SHP triplet per MPI process.

Rename procedure `init_shapefiles` to `shp_triplet_create`.

Use the components for field identifiers of a variable of type
`shp_triplet` instead of storing these field identifiers in variables
of modules `init_shapefiles_m` and `read_field_indices_m`. The dummy
argument hshp of procedure `read_field_indices` becomes
`intent(inout)`.

Create derived type `shp_triplet`. Motivation: we need to manipulate
two triplets of shapefiles in program `eddy_graph`. Use everywhere a
variable of type `shp_triplet` instead of the three variables
`hshp_extremum`, `hshp_outermost`, `hshp_max_speed` when all three of
them appear. Rename character variable `shp_triplet` to
`shp_triplet_dir`.

Prepare for a run of `test_get_snapshot` which receives a
snapshot. Generalize main unit `test_get_snapshot`: it is now
parallelized; it reads a date index from stdin; it sends a snapshot
from process 1 to process 0 if it is run with 2 processes.

The logic of the overlap program will be that all processes access the
triplet of input shapefiles. So modify subroutine
`read_field_indices`: process 0 reads field indices and broadcasts
them. This implies that programs `test_overlap`, `test_read_snapshot`
and `test_read_eddy` use MPI.

Generalize `algorithm.py`.

In program `test_send_recv`, read input SHP triplet from command line
instead of requiring it to be present in the current directory with
the name `SHP_triplet_old`. Generalize `test_send_recv`: read
`ishape_last` from file. In `test_send_recv`, all processes must now
access the triplet of shapefiles since process 0 reads field
indices. For the sake of uniformity, read and broadcast k1 from
process 0.

Change of idea: make date index an intent in argument of procedure
`read_snapshot`. Replace dummy arguments `ishape_first` and scalar
`ishape_last` by k1 and array `ishape_last`. It is now the task of
`read_snapshot` to find the ishapes to read. This seems clearer.

Organize better the directory `Input`: create sub-directories for regions.

Big change: use SHP triplets that can contain several snapshots. So
program `test_overlap` reads a single SHP triplet. The dates that
`test_overlap` should read are now specified in the input
namelist. SHP triplet directory must now contain a file named
`contents.csv`. `test_overlap` reads `contents.csv` into variables k1
and `ishape_last`. So there is no longer any need to read the number
of entities in one of the shapefiles.

For each region, concatenate SHP triplets for dates 2006/01/01 and
2006/01/02.

Read namelist from process 0 in program `test_send_recv`: it is
simpler since it is the default setting of mpiexec and I do not see
any drawback.

In programs `test_read_snapshot` and `test_send_recv`, just hard code
for now the ishapes we want to read in the SHP triplet.