Make Assembler single-use

[plafer]

With this PR it is no longer possible to use a single instance of Assembler to assemble multiple programs.

Simplifies #1401.

[plafer]

Not sure if we should remove with_kernel() in this PR as well?

[bitwalker]

We need a way to construct the Assembler with only a single kernel library, so we probably still need it. If we have metadata associated with a Library that tells us whether it is a kernel library or not, then we can probably make it less explicit and check that we've only added a single library of kernel type in add_library

[bobbinth]

Looks good! Thank you! I left just one small comment inline.

I pushed a few small commits. The biggest change was removing PhantomCall struct (doesn't seem like it was used in any meaningful way).

Also, I think there is a pretty good way to combine ProcedureCache and MastForestBuilder - should make the structure quite a bit cleaner IMO - but we can do this in a different PR.

Lastly, I think there may be a relatively simple way to avoid introducing wrapper modules for the ModuleGraph. Here is how it could work:

We have resolve_target() method in the assembler. This methods seems to be responsible for mapping procedure invocations to their corresponding MAST roots. My understanding is that if it can't resolve a procedure reference, it returns an error.

If the above is correct, we could do the following:

First, update the ModuleGraph::resolve_target() to return something like ResolvedTarget::Unresolved variant if procedure resolution fails. Then, in Assembler::resolve_target() we could do something like this:

...
let resolved = self.module_graph.resolve_target(&caller, target)?;
match resolved {
    ResolvedTarget::Phantom(digest) | ResolvedTarget::Cached { digest, .. } => Ok(digest),
    ResolvedTarget::Exact { gid } | ResolvedTarget::Resolved { gid, .. } => Ok(self
        .procedure_cache
        .get(gid)
        .map(|p| p.mast_root(mast_forest))
        .expect("expected callee to have been compiled already")),
    ResolvedTarget::Unresolved(proc_path, error) => {
        // check if the procedure exists in the store; if not return the error
        match self.store.get_procedure_hash(proc_path) {
            Some(digest) => Ok(digest),
            None => Err(error),
        }
    }
}

If the above works, I think the changes to the current ModuleGraph should be minimal. But it's also possible that I'm missing something. cc @bitwalker.

[bobbinth]

Could we add a comment to explain why we don't need to do anything here.

[bitwalker]

I'm assuming this was unused?

[bitwalker]

LGTM - just one question I left as a comment