Advancing fundamental ppmpf recursive macro construct.

A series of changes have been made in order to make it easier to introduce
safer ways of constructing series of tokens and other constructs from ppmpf
collections like tuples. Specifically:

    1) PPMPF_TUP_1EMPTY, PPMPF_TUP_1GET are for the () enclosed "safe" ppmpf
       tuples. These are the same as ppmpf tuples, but every element is
       parenthesis enclosed. These two are transitional macros.

    2) The recursive macro construct in <odreex/ppmpf/algorithms/fold.hh> is
       upgraded to a version that can reach a depth of 2^16 (aka 65536 items).
       This is still in transition phase so it is coexisting with the older
       version wired up to 10000 elements for the time being.

    3) The macro construct in (2) has also been reimplemented as to be a fully
       metafunction macro based, thus allowing for a wider range of high order
       function emulation requiring recursive / iterative application over
       ppmpf collection items.

    4) There is a greater separation of "metamacros" deployed in the this
       construct, which of course does not limit itself to folding anymore.
       These are making part of the <odreex/ppmpf/algorithms/fldaux.hh> file
       and may have some duplicates within fldaux.hh and mimic functionality
       of assistive metamacros defined in <odreex/ppmpf/algorithms/fold.hh>.
       Again, all of this due to transition phase to the implementation with
       increased depth.

    5) Other minor fixes like a clone of PPMPF_APPLY into PPMPF_APPLY2 for
       failback controlling for the time being.
Added PPMPF_UTUP_FOLDL, PPMPF_UTUP_FOLDR

These will substitute current PPMPF_TUP_FOLDL, PPMPF_TUP_FOLDR high order
macros after transition to the new construct is done. The _TUP_ token in the
identifiers involved, will signify "safe" tuples, aka parenthesis enclosed
comma separated tokens in a parenthesis enclosed series.
Added PPMPF_UTUP_FOLDL_OF for unsafe tuple folding.

This will eventually take over the current PPMPF_TUP_FOLDL_OF implementation,
which itself will be converted into safe tuple mode. Still in transition!
Introduced ppmpf safe tuple constructor, resolved #8

This is the ppmpf safe tuple constructor, the following rules are valid:

    1) PPMPF_TUPLE()      -> ()
    2) PPMPF_TUPLE(1)     -> ((1))
    3) PPMPF_TUPLE(1,2)   -> ((1),(2))
    4) PPMPF_TUPLE(1,[],) -> ((1),([]))

Notice that if the last element used is a token with special characters, the
trailing comma is used as an escape character. Special characters are all
those that if concatenated with a random character, they result in at least
one invalid token. Tests have been added as well.
Introduced initial zipwith macro for ppmpf tuples.

Support is for safe ppmpf tuples right now, up to nine safe tuples
supported, tests were added separately.
Added zip macro from 2 to 9 ppmpf tuples, added tests
Simplyfing Makefile.am instructions, resolves #10
Added more tests to PPMPF_TUP_ZIP, up to 5 safe ppmpf tuples.
Introducing PPMPF_SEQ_AT09 for fast random access in ppmpf sequences.

This function macro will allow random access to ppmpf sequences but only
between index range [0,9] of a ppmpf sequence. It is implemented as an
an assistive metafunction macro in its purpose.
Minor tweaks to test makefile, logging added.
Added timers, make targets: ctim, jtim, tctime.

It is now possible to get the time required to compile a test with "make ctim"
or for all with "make tctime", while the timed version of "make just" is the
"make jtim" target. Errors are exported always to an errors.log file, as well
as times when asked for, in the form of CSV entries.
Merging tests with ppmpf branch, timing and testing.

High order functions like zip, zipwith are merged with the new and improved
tests in autotools for all ppmpf and ample testcases, as well as timing
compilation and running time measuring functions for each test.
Test timing targets export compiler in CSV entries.

 * Fixed a typo in the zipwith test.
 * Second item in the CSV entries of errors.log is compiler path.
Several tested features merged into devbox branch.

 1) Test timing during make targets for tests (compile, run).
 2) High order functions for zip, zipwith for safe tuples completed.
 3) Extra tests have been written for high order function macros.
 4) Logging into errors.log file introduced.
 5) The errors.log file contains csv entries for timing, compiler path etc.
 6) Safe and unsafe ppmpf tuple concepts introduced, transition started.
 7) New and improved recursive macro expansion folding construct (up to 65536
    metafunction macro recursive expansion depth allowed, locked temporarily
    to 10000, transition started).
Getting fast random access for limited ppmpf sequence ranges.
Some copyright year updates missed, issue tracker.
Fixed some Makefile.am regressions.