(API Change) Refactor module handling

Changed API:
- char *obs_find_plugin_file(const char *sub_path);

  Changed to: char *obs_module_file(const char *file);

  Cahnge it so you no longer need to specify a sub-path such as:
  obs_find_plugin_file("module_name/file.ext")

  Instead, now automatically handle the module data path so all you need
  to do is:
  obs_module_file("file.ext")

- int obs_load_module(const char *name);

  Changed to: int obs_open_module(obs_module_t *module,
                                  const char *path,
                                  const char *data_path);
              bool obs_init_module(obs_module_t module);

  Change the module loading API so that if the front-end chooses, it can
  load modules directly from a specified path, and associate a data
  directory with it on the spot.

  The module will not be initialized immediately; obs_init_module must
  be called on the module pointer in order to fully initialize the
  module.  This is done so a module can be disabled by the front-end if
  the it so chooses.

New API:
- void obs_add_module_path(const char *bin, const char *data);

  These functions allow you to specify new module search paths to add,
  and allow you to search through them, or optionally just load all
  modules from them.  If the string %module% is included, it will
  replace it with the module's name when that string is used as a
  lookup.  Data paths are now directly added to the module's internal
  storage structure, and when obs_find_module_file is used, it will look
  up the pointer to the obs_module structure and get its data directory
  that way.

  Example:
  obs_add_module_path("/opt/obs/my-modules/%module%/bin",
                      "/opt/obs/my-modules/%module%/data");

  This would cause it to additionally look for the binary of a
  hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so
  (or libfoo.so), and then look for the data in
  /opt/obs/my-modules/foo/data.

  This gives the front-end more flexibility for handling third-party
  plugin modules, or handling all plugin modules in a custom way.

- void obs_find_modules(obs_find_module_callback_t callback, void
                        *param);

  This searches the existing paths for modules and calls the callback
  function when any are found.  Useful for plugin management and custom
  handling of the paths by the front-end if desired.

- void obs_load_all_modules(void);

  Search through the paths and both loads and initializes all modules
  automatically without custom handling.

- void obs_enum_modules(obs_enum_module_callback_t callback,
                        void *param);

  Enumerates currently opened modules.

libobs/obs.c

@@ -24,6 +24,7 @@
 
 struct obs_core *obs = NULL;
 
+extern void add_default_module_paths(void);
 extern char *find_libobs_data_file(const char *file);
 
 static inline void make_gs_init_data(struct gs_init_data *gid,
@@ -540,6 +541,7 @@ static bool obs_init(const char *locale)
 
 	obs->locale = bstrdup(locale);
 	obs_register_source(&scene_info);
+	add_default_module_paths();
 	return true;
 }
 
@@ -561,6 +563,8 @@ bool obs_startup(const char *locale)
 
 void obs_shutdown(void)
 {
+	struct obs_module *module;
+
 	if (!obs)
 		return;
 
@@ -582,9 +586,17 @@ void obs_shutdown(void)
 	proc_handler_destroy(obs->procs);
 	signal_handler_destroy(obs->signals);
 
-	for (size_t i = 0; i < obs->modules.num; i++)
-		free_module(obs->modules.array+i);
-	da_free(obs->modules);
+	module = obs->first_module;
+	while (module) {
+		struct obs_module *next = module->next;
+		free_module(module);
+		module = next;
+	}
+	obs->first_module = NULL;
+
+	for (size_t i = 0; i < obs->module_paths.num; i++)
+		free_module_path(obs->module_paths.array+i);
+	da_free(obs->module_paths);
 
 	bfree(obs->locale);
 	bfree(obs);
@@ -603,6 +615,7 @@ uint32_t obs_get_version(void)
 
 void obs_set_locale(const char *locale)
 {
+	struct obs_module *module;
 	if (!obs)
 		return;
 
@@ -610,11 +623,12 @@ void obs_set_locale(const char *locale)
 		bfree(obs->locale);
 	obs->locale = bstrdup(locale);
 
-	for (size_t i = 0; i < obs->modules.num; i++) {
-		struct obs_module *module = obs->modules.array+i;
-
+	module = obs->first_module;
+	while (module) {
 		if (module->set_locale)
 			module->set_locale(locale);
+
+		module = module->next;
 	}
 }