Folds get elementary macro function argument binding support.

In short, the whole point of this commit is to introduce parenthesis enclosed
preprocessor tokens as lambda triggers when passed as arguments to function
macros used for left and right folds.

Further details
---------------

Placeholders _1,_2,__1,__2 are now part of <odreex/ppmpf/fold.hh> instead of
the <odreex/ppmpf/prse.hh> header. The PPMPF_PRSE_IBND* macros have been
moved to their own header as PPMPF_IBND* macros from that same header. The PLH
placeholder comma triggering functions are in their own <odreex/ppmpf/plh.hh>
header. The PPMPF_IBND will eventually serve as a strict but optional syntax
checker for argument binding as is used by the folding apparatus. Several
other minor changes related to refactoring.

The most important change however is that folding macro constructs allow to
control argument binding for the binary function macros used in folds and
whether the arguments passed to them will be "dereferenced" with PPMPF_DREF,
when used as _1 / _2, or not when used as __1 /__2. The two kinds of ppmpf
placeholders can be used in any combination as in the following examples:

    ((MY_MACRO,_1),_2))    -> MY_MACRO(PPMPF_DREF(arg1),PPMPF_DREF(arg2))
    ((MY_MACRO,__1),__2))  -> MY_MACRO(arg1,arg2)
    ((MY_MACRO,_2),__1))   -> MY_MACRO(PPMPF_DREF(arg2),arg1)
    ((MY_MACRO,__2),_2))   -> MY_MACRO(arg2,PPMPF_DREF(arg2))
    ...
    ... and so on.

The parenthesized sequence acts as a "lambda" trigger and it only allows two
preprocessor tokens per parenthesis for the time being. The following examples
use the binary PPMPF_CAT function in ppmpf collections folding. Notice that
PPMPF_CAT requires non - parenthesized arguments to be passed to it, thus the
_1 and _2 forms of the placeholders are used :

    PPMPF_SEQ_FOLDL_OF(((PPMPF_CAT,_1),_2),(a)(b)(c)(d)(e)(f)(g)) -> (abcdefg)
    PPMPF_TUP_FOLDL_OF(((PPMPF_CAT,_1),_2),(a,b,c,d,e,f,g))       -> (abcdefg)
    PPMPF_TUP_FOLDL_OF(((PPMPF_CAT,_2),_1),(a,b,c,d,e,f,g))       -> (gfedcba)
    ...
    ... and so on.

For the time being, only placeholders can be used with this notation. This
syntax is eventually going to be expanded to cover other ppmpf constructs and
C99 preprocessor tokens in general and it is always going to be triggered by
a parenthesized token (triggering "lambda" mode) passed as a macro function
argument. PPMPF_IBND and other macros are to be fully developed for that exact
purpose.

When a binary macro is used out of a "lambda" triggering context, the default
behavior is to pass the arguments as parenthesis enclosed tokens, i.e.:

    PPMPF_SEQ_FOLDL_OF(MY_MACRO,(a)(b)(c))
        -> used as   : MY_MACRO((a),(b))...
        -> equivalent: PPMPF_SEQ_FOLDL_OF(((MY_MACRO,__1),__2),(a)(b)(c))