cfgparser: add support for growing memory objects

We've found a vector of pointers in a game which grows by calling
realloc(). It grows by the size of a pointer each time until it
reaches its final size. The allocation of the first pointer is
always a malloc(). With the current code we would have to copy
the same dynamic memory config over and over for all possible
sizes. This is cumbersome and looks like this:

dynmemstart GrowingClass 16 0x754 0x8
dynmemend
dynmemstart GrowingClass 24 0x754 0x8
dynmemend

So introduce growing object support in config parsing. Introduce
a config command "dynmemgrow" which is used within the dynamic
memory config. Make it possible to use it instead of "dynmemstart"
as well in case the initial malloc() is unknown. Support only
growing by adding for now and introduce a vector for storing the
current size for each allocated object of this growing class.
Looks like this:

# Initial malloc() and growing by realloc() known

dynmemstart GrowingClass 8 0x73c 0x8
# dynmemgrow <size_min> <size_max> <operator><growing size> ...
# ... <code_addr> <stack_offs>
dynmemgrow 16 40 +8 0x754 0x8
dynmemend

# Only growing by realloc() known, malloc() config becomes invalid

# dynmemgrow <class_name> <size_min> <size_max> ...
# ... <operator><growing size> <code_addr> <stack_offs>
dynmemgrow GrowingClass 16 40 +8 0x754 0x8
dynmemend
cfgoutput: add support for growing memory objects

Now that we've added the config parsing for growing memory objects
it's time to update the output of these. So add a part starting
with "growing" to the dynamic memory output. Looks like this:

dynmem: GrowingClass 8 0x73c 0x8 growing 16 40 +8 0x754 0x8
libmemhack: add growing config transfer and parsing

We have growing config parsing and output in ugtrain. Now transfer
this config via the input FIFO to libmemhack. Parse it there and
return the read config output. FIFO data looks like this:

1;0;0x0;0x0;grow;16;40;+8;0x754;0x8

The keyword "grow" followed by a ';' marks that there is growing
configured for this memory class.

The debug output looks like this:

[memhack] config[0]: mem_size: 0; code_addr: 0x0; stack_offs: 0x0
[memhack] config[0] growing: size_min: 16; size_max: 40; add: 8; \
code_addr: 0x754; stack_offs: 0x8
memmgmt: add support for growing memory objects

The libmemhack already knows about growing memory objects.
Now compare min. size, max. size, matching of the growing method
and code addresses for growing object configs as well. If it finds
a related memory allocation, send the new size to ugtrain as well.
Even better and simpler, always send the allocation size to ugtrain.
Store it in the growing config. The size can help us to detect out
of memory object bounds accesses.