Managers provide the ability to instantiate and utilize the various plugins
in Snort++.  There is a separate manager class for each plugin type, plus
one for modules, plugins, scripts, and packets.

The only plugin that is reloadable is Inspector.  It has reference counts
so that it won't be freed while an active flow is using it.

When reload removes an inspector, packet threads normally call tterm() on
the old inspector while terminating the removed map.  If the inspector still
has references on that packet thread, for example through flow->gadget,
InspectorManager defers tterm() instead.  The pending entry is thread local
and stores only the Inspector*.  It also takes a self-reference so the
inspector object cannot be deleted before the pending tterm() is drained.

The pending entry intentionally does not store NetworkPolicy or
InspectionPolicy pointers because the old SnortConfig can be reaped before
the deferred tterm() runs.  Pending tterm() entries are drained during
thread reinitialization, thread termination, or when a flow releases the
pending service gadget reference once the thread's refcount has dropped
to the self-reference.

During reload, InspectorManager does not blindly rebind stale flow gadgets.
If a pending tterm() has already run, packet processing clears the old
gadget and resets flow->service to nullptr so binder and wizard can
rediscover the service.

If reload initializes a same-API inspector while an old same-API inspector
is removed, the old inspector's tterm() may run before the new tinit() to
avoid colliding thread-local state.  Other referenced removed inspectors
stay on the deferred cleanup path.

Only the action, codec, and inspector managers have thread local state:

* action manager has an action function
* codec manager has the grinder and related stats
* inspector manager has the current InspectorVector pointer and pending
  deferred tterm() entries

Some Lua files are here as they are coupled closely with C++ code in this
directory (module_manager.cc):

* bootstrap.lua provides FFI for adding table names and prefixes to
  snort's lua whitelist. This whitelist is used to ignore warnings
  when snort modules are not found for table names. This file also
  has the FFI used to resolve file includes in lua file.

* finalize.lua provides the ability to parse a Lua configuration.  It
  is much easier to traverse the Lua tables via Lua itself.  This file
  leverages the LuaJIT FFI to open and close tables and set values.

* snort_plugin.lua provides FFI for script plugins (ips options and
  loggers).  This is pretty thin at the moment and should be expanded to
  provide more data.

These Lua files get installed in LUA_PATH.

Module manager recursively sets default values for all parameters within a
module.  While list items have default values, default lists are not
provided by modules; that is strictly done in Lua with snort_defaults.lua.
This not only simplifies the code somewhat, it also makes the most sense
from a user perspective.

The ConnectorManager (and associated) classes manage the set of Connector
objects.  One ConnectorCommon is created to encapsulate a vector of
configuration objects.  At thread startup, these config objects are used
to instantiate thread specific instances of each configured Connector.

