Parsing hooks
For now if an error have occured the parsing stops, throws an error and all the parsing result is discarded.
<details>
For example a file format (```pcap``` in the case I'm working on now) contains some records. And it throws somewhen. I have added ```print``` calls to the generated parser (I have added a couple (one is for windows, one is for linux) of records' types to parse USB captures, I'm going to release them soon), the log makes sense (at least the enums values and sizes are the ones that expected), but sometimes a broken record is processed and all the result is discarded. The broken record has incorrect and insane value for size, which result in running out of stream boundaries. The files were generated by Wireshark (converted from pcapng), so I assume them valid. For now I have not found what happened.
</details>

I guess there may be good use cases when parsing broken files is needed. So we need a way to deal with such cases. In particular we need a way to capture the exceptions produced and do some custom processing.

IMHO the best way to deal with it is to have some hooks for that. What the hooks do we need? For every property in a struct KSC should create a method, which is used to parse that field. For parsing a sequence it should create a pair of methods, one is for parsing an item and another one using the latter one is for parsing a sequence. Methods should be deduplicated. I mean, that if we have ```n > 1``` properties having the same type, the compiler should generate, depending on the language, either ```n+1``` methods (1 method to read the type and n references to it to read members).

What should the methods signatures look like?
I propose
```python
def _read_<field_name>(self, fieldName, buffer)
```
for fields and instances
```python
def _read_element_<field_name>(self, fieldName, index, buffer)
```
for sequence elements
```python
def _read_type_<type_name>(self, fieldName, buffer)
```
for types.

The example

```yaml
meta:
  id: O
seq:
  - id: a
    type: u4
  - id: b
    type: u4
  - id: c
    type: u4
    repeat: expr
    repeat-expr: b
```

should generate something like
```python
class O(...):
   ...
   def _read_type_u4(self, fieldName, buffer):
     ...
   
   _read_a=_read_b=_read_element_c=_read_type_u4
   def _read_c(self, fieldName, buffer):
      for ...:
         ...=self._read_element_c(...)
```