We're using the `mlua` crate, since it seems most actively maintained
and performant.

You can't do anything with them other than call `tostring` on them, but
even that is helpful in test cases!

This is the spackle that parses a source file using tree-sitter, and
calls a Lua function with it and an empty stack graph.  The Lua function
can do whatever it wants to walk the parse tree and add nodes and edges
to the graph.

This one is fun, because `SpanCalculator` holds a reference to the
file's source code, while the `mlua::UserData` works best for Rust types
that are 'static.

To get around this, we make sure to only ever create `SpanCalculator`
wrappers for source data that is owned by the Lua interpreter, and add
that source data as a user value of the Lua wrapper that we create.
That should cause Lua's garbage collector to ensure that the source code
outlives the `SpanCalculator`, making it safe for us to transmute the
source reference to a 'static lifetime.

The stack graph builder now imports the `lsp-position` module before
handing control to your Lua script.  That lets you create a span
calculator, and use that to fill in spans and definiens for the stack
graph nodes that you create.