Construct capturer.

"capturer" is synonym of delphi's "frame object". In future implementation will be changed to allow capturing by value. To prevent future misunderstanding word "capturer" is used.

There are 2 main questions:
1. How to allocate captured variables.
2. How to represent pointers to closure ("reference to" variables).

1. Current approach is Delphi-like:
+ for each procedure which have nested closures define special object (let's call it capturer) (implemented);
+ frame object created at begin of it's owner-routine activation (implemented);
+ anonymous routine became method of frame object (implemented);
- variables which are used from closure are called "captured". Captured variables become fields of frame object (not implemented);
- access to captured varibles in case of routines nesting level more than 1 is done using capturer "parent link" (not implemented);

2. Again Delphi-like solution:

  Reference to anonymous function should
  + point to frame object
  + point to anonymous method
  + be used by compiler to manage frame object's dynamic memory
  to solve this problems for each anonymous method we define interface which contains single method "Apply". Now references to procedure is interface. To call closure we call single procedure of interface.

Let's call described implementation "closures via interfaces". There is positive sides:
+ simple;
+ delphi-compatible.
Negative:
- overhead: call to closure is done through vmt which contains function wrapped into interface wrapper;
- doesn't suit for capturing by value;
- doesn't solve problem of different pointers to routines compatibility.
Call closure using parentheses;

Allow to use syntax:
+ p(arg1, arg2, arg3, ...); in case of many parameters;
+ p; in case of 0 parameters.
Hack 2 places where call to procvar is processed.
Good error messages.