Integer division behavior with negative result is not unified
The integer division operation currently doesn't behave the same way in all languages, if the quotient (division result) is a negative number. Here's a summary table (`-20 / 12 = -1.666...`; `69 / -20 = -3.45`):

| Language | `-20 / 12` | `69 / -20` |
| -------- | ---------- | ---------- |
| C++      | -1         | -3         |
| C#       | -1         | -3         |
| Go       | -1         | -3         |
| Java     | -1         | -3         |
| **JavaScript**       | **-2**         | **-4**         |
| **Lua**      | **-2**         | **-4**         |
| Nim      | -1         | -3         |
| Perl     | -1         | -3         |
| PHP      | -1         | -3         |
| **Python**   | **-2**         | **-4**         |
| **Ruby**     | **-2**         | **-4**         |
| Rust     | -1         | -3         |

The User Guide says [this](https://doc.kaitai.io/user_guide.html#_arithmetic_operators):

> If both operands are integer, result of arithmetic operation is integer, otherwise it is floating point number. For example, that means that `7 / 2` is `3`, and `7 / 2.0` is `3.5`.

But that says nothing about how the division on integers should behave on negative results. There are two options: **true** integer division always rounding to the closest lower number ([`math.floor(a / b)`](https://mathworld.wolfram.com/IntegerDivision.html)) and a float division, whose result will be converted ([truncated](https://www.programming-idioms.org/idiom/80/truncate-floating-point-number-to-integer)) to integer (which means trucating towards 0). The target languages now use both these options, so it would be nice to unify it to ensure same results for different KS targets.

But I'm actually 100% not sure which approach should be used. Probably the one with integer conversion makes more sense, because it expresses the intention better. The KS expression language doesn't want to yield a float when the operands are integers, so it's natural to calculate the result as float and then cast it to integer. That would imply that the behavior of JavaScript, Lua, Python and Ruby is incorrect.

Is that right? Strictly speaking, it's a BC break with 0.8, but as @GreyCat said [here](https://github.com/kaitai-io/kaitai_struct/issues/155#issuecomment-616213270) that we've already done that, so I guess it's OK?