Construct: parametrized types
[I ran into an issue before with using parametrized types with the Construct target](https://github.com/kaitai-io/kaitai_struct/issues/377#issuecomment-1025263562). It seems like passing parameters is not currently supported. I would like discuss an approach to fixing it.

Here's an example demoing the issue:
```yaml
seq:
  - id: top
    type: thing(_index)
    repeat: expr
    repeat-expr: 3
types:
  thing:
    params:
      - id: i
        type: u4
    seq:
      - id: dat
        size: i
```
Outputs the following:
```py
from construct import *
from construct.lib import *

index__thing = Struct(
	# this.i is not actually set anywhere!
	'dat' / FixedSized(this.i, GreedyBytes),
)

index = Struct(
	'top' / Array(3, LazyBound(lambda: index__thing)),
)

_schema = index
```
This results in a `KeyError` because `thing` tries to access `this.i`, but `this.i` is not actually passed to `thing` at all.

I manually modified the above Construct code to produce something that produces the expected output (`this._index` is available to us via a context value from `Array` ([docs](https://construct.readthedocs.io/en/latest/basics.html?highlight=this#hidden-context-entries))):
```py
from construct import *
from construct.lib import *

def thing_w_index(x):
	return Struct(
		'dat' / FixedSized(x, GreedyBytes),
	)

index = Struct(
	'top' / Array(3, LazyBound(lambda: thing_w_index(this._index))),
)

_schema = index
```
```
>>> from index import index
>>> index.parse(b'1234')
Container(top=ListContainer([Container(dat=b''), Container(dat=b'1'), Container(dat=b'23')]))
```
It also seems to work with more complex parameters
```py
from construct import *
from construct.lib import *

param__other = 'param__other' / Struct(
	'field1' / Int8ub,
)

def object_example(val):
	return Struct(
		'field2' / FixedSized(val.field1, GreedyBytes),
	)

param = 'param' / Struct(
	'something' / LazyBound(lambda: param__other),
	'top' / LazyBound(lambda: object_example(this._.something)),
)

_schema = param
```
```
>>> from param import param                                                                    
>>> param.parse(b'\x0512345')
Container(something=Container(field1=5), top=Container(field2=b'12345'))
```

Does this approach seem reasonable for Construct parametrization? I don't like that this creates a new, almost entirely identical struct instance for every parameter. I'm very much open to a better method for doing this.