nested/imported types don't support parameters (:: syntax ignores parameters)
Consider the following two files:

```yaml
# common_types.ksy
meta:
  id: common
  endian: be
types:
  my_type:
    params:
      - id: my_param
        type: s2
    seq:
      - id: param_thing
        type: s4
        repeat: expr
        repeat-expr: my_param
```

```yaml
# main.ksy
meta:
  id: test
  endian: be
  imports:
    - common_types
seq:
  - id: thing
    type: common::my_type(2) # will throw an error when compiled
```

As the comment suggests, common::my_type(2) will throw an error when attempting to compile. 

in the case that `my_type` *does* have its param *and* the type referenced in `main.ksy` was just `common::my_type`, it will be treated as an opaque type and compile (as it... should(?)).

if `my_type` didn't have a param and `common::my_type(2)` was just `common::my_type` it will find `my_type` in the other file and compile properly.

---

I assume that when the compiler encounters `::` in a type it will attempt to do something like this:
```
if (referenced type exists) {
  use that type
} else if (type is a valid opaque type name) {
  treat it as an opaque type
} else {
  give up and throw an error
}
```

if this is the case, this could theoretically be fixed by adding a third condition after the others fail that checks to see if () exists at the end of the current "level" of nested identifiers