Custom processors are difficult to deal with in JavaScript
## Problem

If I have a file:

```yaml
meta:
  id: hello_world
seq:
  - id: bytes
    size-eos: true
    process: lz4
```

and then target JavaScript, the resulting code tries to find the `lz4` processor by calling `require('Lz4')`. It's difficult to make this `require` call resolve. I can see three options:

### Publish a package to NPM called `lz4` and depend on it

Having to publish a package to use a custom processor is inconvenient. Then there's the problem of finding a good name with no conflicts. (`lz4` [already exists](https://www.npmjs.com/package/lz4), of course.) FInally, the NPM registry does not allow package names with uppercase letters, so this does not work on case-sensitive filesystems.

### Modify `NODE_PATH` to make the module resolve

This works for Node, but is a fairly non-standard way of doing things. It also doesn't work if we eventually support generating ES modules (cross-reference #267), which no longer respect `NODE_PATH`. It doesn't work outside of Node, but there are generally similar configurations available for other tools.

### Add `"Lz4": "file:./src/lz4" to `package.json`

For this to work, `src/lz4` must be a directory and must contain a `package.json` file. The package manager will create a link to this directory inside `node_modules` during installation.

This is probably the best option available today, and the one I'm currently using. It still feels overly complex and difficult to discover.

## Possible Solutions

I have some ideas to solve this, possibly with compatibility breaks:

* My preference: Generate a relative import instead (eg `require('./Lz4')`). This seems fairly easy to work with.
* Don't generate an import at all, but accept the processor constructor as a parameter to the parser's constructor. This seems fine, but might be inconsistent with the way that generators other languages work.
* Create a way to configure how the import is generated, either through the `.ksy` file or on the command line. This is more complicated and maybe a bigger conversation.