`_root` / `_parent` chain broken by recursive use of the top-level type
If the top-level type is used recursively, `_root` (and `_parent` in some target languages) refers to the closest ancestor in the object tree that has the top-level type, not to the actual root of the object tree.

Consider the following .ksy snippet:

```ksy
meta:
  id: nav_root_recursive
seq:
  - id: value
    type: u1
  - id: next
    type: nav_root_recursive
    if: value != 0x01
instances:
  root_value:
    value: _root.value
```

If you try this for example on bytes `80 01`, you get the following object tree (as of KSC at commit [`6aef6fae`](https://github.com/kaitai-io/kaitai_struct_compiler/tree/6aef6faeb00d4800d493460bc0f83483e60bad01)):

```
├── value = 0x80 (= 128)
├── next [NavRootRecursive]
│   ├── value = 0x1 (= 1)
│   └── rootValue = 0x1 (= 1)
└── rootValue = 0x80 (= 128)
```

As you can see, the value of `next.rootValue` is `1`, which indicates that `_root` in `next`'s context refers to `next` itself, not the root node of the object tree. `_root` is not passed from the root object to `next`, so `next` falls back to using `this` as its `_root`.

This is visible in the generated code, see JavaScript for example:

```js
  NavRootRecursive.prototype._read = function() {
    this.value = this._io.readU1();
    if (this.value != 1) {
      this.next = new NavRootRecursive_.NavRootRecursive(this._io, this, null);
    }
  }
```

Notice the `null` being passed as an argument to `_root` (instead of `this._root` as usual).

In some languages, the same problem affects not only `_root` but also `_parent` - see e.g. Java:

```java
    private void _read() {
        this.value = this._io.readU1();
        if (value() != 1) {
            this.next = new NavRootRecursive(this._io);
        }
    }
```

The `_parent` problem can be demonstrated for example as follows (again, this is meant to work on bytes like `80 01`, but it can be easily adjusted for pretty much any binary file):

```ksy
meta:
  id: nav_parent_recursive
seq:
  - id: value
    type: u1
  - id: next
    type: nav_parent_recursive
    if: value == 0x80
instances:
  parent_value:
    value: _parent.as<nav_parent_recursive>.value
    if: value != 0x80
```

Accessing the `next.parent_value` instance would fail in Java, since it doesn't pass `_parent` to invocations of the top-level type (so `next._parent` would be `null`).
