Preprocessor functors, vertical patterns, integral constant expressions.

With this commit, ppmpf becomes fully capable of expanding macro constructs
in the vertical sense. The horizontal patterns are the ones resulting from
macros expanding within the same source code line. Vertical patterns are the
ones expanding in multiple lines and allow for more complex and performant
cases of source code boilerplate generation through the preprocessor. This
is done by using set builder-like notation for specifying the left-closed,
right-open interval of expansion using human-readable integral constant
expressions. A way of visioning such expansion is through macro sets, that
consist of a single macro or file containing other source code boilerplate
being expanded several times in vertical.

Nothing but a C99 preprocessor is used and in order to have this facility
inclusion of <clause/ppmpf/vxpp.hh> is required. Prior to concluding with
the documentation for this complicated feature, some examples are given
for quick use. Remember to use -E -P flags for seeing the result of
preprocessor elaboration on your terminal. In relation to the gcc preprocessor,
a known performance regression is circumvented through the undocumented
-ftrack-macro-expansion=0 flag; this does not enable some non C99 compliant
feature, it only disables the internal (and useless) macro tracking gcc
does. Users of clang do not have such a problem (they have others in relation
to non-compliance to the standard). It is interesting that while clang may
provide a faster preprocessor than gcc, even when the latter is used with the
known performance regression fix, clang will fail in extreme depths of
iteration.

In the first example the macro f is invoked 50 times with three arguments that
are derived from integral constant expressions. These are evaluated exclusively
by the preprocessor, and after PPMPF_VXPP_FMAPOF(0) has completed expansion
of set identifier zero (0), it undefines PPMPF_VXPP_SET0. The basic construct
is a ppmpf 2-tuple, where the function f is enclosed in parentheses while
its arguments follow in another enclosure. After a comma, the second enclosure
contains two integral constant expressions representing the endpoints of the
integers that are passed to said macro. All arguments to be passed to the f
macro, can be represented as formulas - provided the constitute
integral constant expressions that can be evaluated.

    #define PPMPF_VXPP_SET0(n) ((f)(n,n*n,n%5),(0,50))
    #include PPMPF_VXPP_FMAPOF(0)

Should we require to pass a constant argument to the previous macro, we only
need to enclose it within parentheses:

    #define PPMPF_VXPP_SET0(n) ((f)(n,("!"),n*n,n%5,("a token!")),(0,50))
    #include PPMPF_VXPP_FMAPOF(0)

The fastest invocation is made when no second enclosure follows the macro one,
where the macro function is invoked with n as f(n) by default:

    #define PPMPF_VXPP_SET0(n) ((f),(0,50))
    #include PPMPF_VXPP_FMAPOF(0)

Furthermore, the plain repetitive inclusion mode is when the first argument is
not enclosed using parentheses. This allows us to expand that file within
the integral constant expression interval specified, where PPMPF_N(0) is
an implicitly defined macro we can invoke for identifier 0 and give us a
decimal number within that interval to use in our file template:

    #define PPMPF_VXPP_SET0(n) (<path/to/your/file.hh>,(0,50))
    #include PPMPF_VXPP_FMAPOF(0)

By using the following ppmpf 3-sequence (tokens grouped in three parenthesis
enclosures), we can define a macro to apply on the fly to a comma separated
list of tokens:

    #define PPMPF_VXPP_SET0(n) \
            ()(template<typename...> struct PPMPF_CAT(token_,n) {};)\
              (alpha,beta,gamma,delta,epsilon,zeta,eta)
    #include PPMPF_VXPP_FMAPOF(0)

We can of course use it with another macro that we do not "define" inline, also
controlling some aspects as to additional constant arguments been passed:

    #define PPMPF_VXPP_SET0(N) \
            ()(function(N,extra_argument))(alpha,beta,gamma,delta)
    #include PPMPF_VXPP_FMAPOF(0)

We can also use a file in the same manner, where PPMPF_VXPP_ITEM(0) is an
implicitly defined macro resolving to a different token from the token
list we pass in the second parenthetical enclosure.

    #define PPMPF_VXPP_SET0(x) (<path/to/your/file.hh>)(a,b,c,d,e,g,h,i)
    #include PPMPF_VXPP_FMAPOF(0)

In total, there are 10 (ten) different 'ppmpf set macro identifiers', ranging
0 to 9. Expansion occurs if and only if an #include directive is given
accepting as argument the result of the PPMPF_VXPP_FMAPOF invocation with
the respective set identifier. The 'fmap' choice is deliberate, since this
is to evolve into covering the full semantics of categorical functors, for
what concerns boilerplate code generation through token list manipulation,
completing the ppmpf 'map' of the horizontal pattern expansion. All of the
ppmpf macros can be used with either C or C++ for code generation, each with
and iteration depth of 100k (thousand) elements.
Changing my contact email address in the source code.

This is relatively important to me since I do not wish to continue using
a Google email account for my interactions, software or otherwise.