events as types (proof of concept).
planned feature: events can be inherited.
ValParam_<ARGS> to behave as much as (ValParam*).

clear() follows convention established as with AiD.

vp = NULL;  // will not be supported !!!
Meta/Ctti templates.
save typing public when events defined struct.
Recursively 'assign_arg_info' in ArgListI.

(BTW, track added files in MANIFEST).
sketches on revisited state machines.
Handler_<ARGS> to be HandlerX with types info.

- implemented two object-based handlers with
  1 and 2 arguments
- TODO: think what to do with Handler0...
Fix hsm-play after rebase.
(Re)implement all ValParam_<?> <- vparam()

- new ValParamA class template (derived from ValParam)
  and its specializations for 1..9 arguments lists
- template List4..9 constructors
- previous attempts with 1..2 arguments commented out
- later variant of ValParam<? ,3> also commented because
  of surprising compiler error:
  "template parameters not used in partial specialization" !!!
Introduce macros to get concise lists in headers.

- COE_... macros defined temporarily in coe-oev.h
- completed rewrite of all vparam()s and handler()s
- Handler_ template now have specializations
- removed most #if 0's
rparam() now returns RefParam_<ARGS> template.
Ctti & Meta templates to replace old specific _Type.. runtimes.

Note that the following method had a subtle bug:
compared were type_info pointers instead of references
(may need to be fixed in master asap).

template<class _Arg>
 _Arg* ValParam::argptr (size_t index)

TODO: FIXME left in TypeInfo.
examples/chsm.cpp (started, in flux)
chsm: start building the meta properly.

 $ make examples/chsm && ./examples/chsm
 g++ -MMD -rdynamic -g -O2 -Wall -Iinclude -c -o examples/chsm.o examples/chsm.cpp
 g++ -MMD -rdynamic examples/chsm.o -lpthread -lrt -Llib -lcoe -o examples/chsm
 @ init_meta_info --> 0x804c1a8=mSM(root=0x804c1c8)
 @ init_meta_info --> 0x804c1c8=m_S(mXS(sm=0 par=0 size=20 put=0x804a0c0 clr=0x8049f50))
 =================================================================
 @ mSM
   #1 0x804c1a8=mSM(root=0x804c1c8)
 @ mOS
 @ mAS
 @ m_S
   #1 0x804c1c8=m_S(mXS(sm=0 par=0 size=20 put=0x804a0c0 clr=0x8049f50))
 ### START -------------------------------------------------- main
 #### STOP -------------------------------------------------- main
 @ mSM
   #1 0x804c1a8=mSM(root=0x804c1c8)
 @ mOS
 @ mAS
 @ m_S
   #1 0x804c1c8=m_S(mXS(sm=0 par=0 size=20 put=0x804a0c0 clr=0x8049f50))
chsm: uppercase nested typedefs
chsm: burn off meta-info for or_state<>

TODO next:
- introduce type assertions (e.g. to check that initial state is really a child state)
- meta-info for and_state<>
- child lists

@ init_meta_info --> 0x804c1b0=mSM(root=0x804c1c8)
@ init_meta_info --> 0x804c1c8=mOS(mXS(sm=0x804c1b0 par=0 size=20 put=0x804a430 clr=0x804a270) init=0x804c208 chld=?)
@ init_meta_info --> 0x804c208=m_S(mXS(sm=0x804c1b0 par=0x804c1c8 size=12 put=0x804a4d0 clr=0x804a290))
=================================================================
@ mSM
  #1 0x804c1b0=mSM(root=0x804c1c8)
@ mOS
  #1 0x804c1c8=mOS(mXS(sm=0x804c1b0 par=0 size=20 put=0x804a430 clr=0x804a270) init=0x804c208 chld=?)
@ mAS
@ m_S
  #1 0x804c208=m_S(mXS(sm=0x804c1b0 par=0x804c1c8 size=12 put=0x804a4d0 clr=0x804a290))
*** START -------------------------------------------------- main
**** STOP -------------------------------------------------- main
@ mSM
  #1 0x804c1b0=mSM(root=0x804c1c8)
@ mOS
  #1 0x804c1c8=mOS(mXS(sm=0x804c1b0 par=0 size=20 put=0x804a430 clr=0x804a270) init=0x804c208 chld=?)
@ mAS
@ m_S
  #1 0x804c208=m_S(mXS(sm=0x804c1b0 par=0x804c1c8 size=12 put=0x804a4d0 clr=0x804a290))
transition<> -- proof of concept.

mem_fun types defined as nested templates of event's specializations.
Perhaps they should be better moved out and defined in separate class
template, e.g. handler<> ?
Define handler_type<> and use in transition<>.

Attempt to define handler<> class template conflicted with overloaded
template functions 'handler' (!), so I had to name it differently, hence
handler_type<> class template.

TODO: try to use handler_type<> when defining Handler_<> (maybe it'd be
possible to replace all specializations by one general definition).
Simplify Handler_<> definition (thanks to handler_type<>).

Replace specializations with one general class template definition.

Similar trick is not possible with overloaded template functions
handler() because from a method/function prototype a compiler is not
able to "deduce" complex template parameter ARGS :(