Support for post-parsing data transformations via expressions 
The protocol I'm currently working with uses its own kind of data type. It uses a `s4` type to transmit floats, by multiplying them by `100` (implicitly truncating the decimal portion) before transmitting them over the wire. I want to use KS to transform this data back into its intended form, by dividing it by `100.0` (and implicitly casting it back to a float), allowing the application to then use this data directly without any further conversions at the application layer.

I've managed to accomplish this using current mechanisms as follows:
```yaml
meta:
  id: nbo_float
  endian: be
seq:
  - id: nbo_float
    type: s4
instances:
  value:
    value: nbo_float / 100.0
```

Then importing and using `nbo_float` where applicable, as follows:
```yaml
  - id: rtt
    type: nbo_float
```

The problem is that this creates some inconsistency in how data needs to be accessed, depending on its type. Non-`nbo_float` types can be accessed directly, while `nbo_float` types need to be accessed via a nested `.value`.

My proposal is that something similar to `process` (or piggy-back from process) be introduced and support expressions to convert the data as its parsed. As an example, it could look something like this:
```yaml
seq:
  - id: rtt
  type: nbo_float
types:
  - id: nbo_float
  type: s4
  transform: _ / 100.0
```

As a quick hack to accomplish what I wanted, I did the following:
```Shell
find ./ -type f -name "*.py" -exec sed -i -e 's/NboFloat(self\._io)/self\._io.read_s4be() \/ 100/' {} \;
```