In terms of an active Lua implementation for C#, I would recommend checking out MoonSharp:http://www.moonsharp.org/
The developer is active and the most recent update was pushed 2016-02-09
In my opinion, it is one of the better implementations in terms of speed and optimization for Lua < > C#. However in a large scale project that heavily uses Lua you will notice some massive overhead and slow down. (If you need a true implementation of Lua in your project, go with a true Lua implementation in C/C++.)
Dynamic in C# is not restricted to classes only, you can use it anywhere. You can read up more on the dynamic keyword here:https://msdn.microsoft.com/en-us/library/dd264736.aspx
In terms of accessing a Lua instance globally you can use a singleton approach to make a 'Lua Manager' type class to access the Lua state globally. That would be one of the more easier methods of being able to do stuff with a single Lua instance from anywhere in your project.
When you create multiple Lua instances they are entirely separate from each other. Lua does not communicate with multiple states by itself. If you want something like that you will have to code it manually. (Mind you it will involve a hefty amount of work for large scale projects that heavily use Lua.) Lua instances are not designed to communicate between each other. Think of a Lua state like a virtual machine without networking. Everything is closed off to the VM itself. But you can make multiple instances of a VM etc.
As for printing out the entire Lua DB/tables/funcs/etc. you can dump the global object _G. Iterate over its members and dump each part of it, if its a table, step into that table and dump that as well etc. An example of that can be found here:https://codea.io/talk/discussion/138/co ... -variables
(There are other examples of similar around the net.)
Just keep in mind with a C# based Lua implementation there is a lot of overhead. When you want to use a C# object from Lua there is a lot of translation layers going on. The object has to be converted to a Lua friendly instance which usually involves a large amount of reflection being used which turns into more overhead. Accessing the object from Lua also has multiple translation layers going back and forth too. For example if you have a class with some variables and functions that you expose to Lua, there is going to be multiple layers of reflection and translation between C# and Lua using the same object.
If Lua wants to use a variable from the object, such as:
someObject.x = 123;
There is going to be a layer translating someObject to the C# instance, then reflection will be used to find the 'x' property and its type. The 123 will be converted to the appropriate type via more reflection of the properties information and so on.
This can lead to serious overhead and lag if you are constantly talking between the C# app and Lua.