KSC must not know anything about `process` functions
I have implemented a part of cso file format.

It uses 2 different compressions currently unsupported: deflate and lz4. KSC generates incorrect code for them assumming certain structure of their modules. These assumptions are simply wrong. Fortunately the manual fixes are rather small.

For JS target the situation is much worse. KSC fails to compile the ksy for this targets.

The proposal is to shift the knowledge about processors into runtime entirely. Each processor is identified by a string. This string is mapped to a class which is a part of runtime and which gets arbitrary number of arguments. KSC has no assumptions about the class internal structure but knows about its interface.

This construct works nicely for interpreted languages like JS, python and lua since they can import dependencies in runtime. It can work also for Java and C# via reflection.

All the needed imports can be done within the ctor, so if the dependency is not needed, it is not required.

 It can be extended to C++ too the following way:

1 no string mapping to a ctor, everything is done in compile time
2 if a function with the name is used, KSC generates a macrodef having a name drived from processor function and uses the classes with the names generated:

```cpp
#define KAITAI_STRUCT_PROCESS_ZLIB 1

....

ZlibProcessor processor1(args); //need do something here for thread safety

.....

processor1.process(.....)

```

3 the runtime has the following code for every processor function supported:

```cpp
#if defined(KAITAI_STRUCT_PROCESS_ZLIB)
public struct ZlibProcessor:public KaitaiStructProcessor{};
#endif
```

```cpp

#if defined(KAITAI_STRUCT_PROCESS_ZLIB)
#include <zlib.h>
ZlibProcessor::ZlibProcessor(<needed args>){
  <creates needed objects, saves them>
}

ZlibProcessor::process(void * src, void * dst){.....}
#endif


```