Revise package terminology.

doc/src/rust/modules/create.md

@@ -19,8 +19,8 @@ Manually creating a [module] is possible via the `Module` API.
 For the complete `Module` API, refer to the [documentation](https://docs.rs/rhai/{{version}}/rhai/struct.Module.html) online.
 
 
-Make the `Module` Globally Available
------------------------------------
+Use Case 1 - Make the `Module` Globally Available
+------------------------------------------------
 
 `Engine::register_global_module` registers a shared [module] into the _global_ namespace.
 
@@ -44,14 +44,14 @@ module.update_fn_metadata(hash, ["x: i64", "i64"]);
 
 // Register the module into the global namespace of the Engine.
 let mut engine = Engine::new();
-engine.register_global_module(module);
+engine.register_global_module(module.into());
 
 engine.eval::<i64>("inc(41)")? == 42;       // no need to import module
 ```
 
 
-Make the `Module` a Static Module
---------------------------------
+Use Case 2 - Make the `Module` a Static Module
+---------------------------------------------
 
 `Engine::register_static_module` registers a [module] and under a specific module namespace.
 
@@ -69,15 +69,18 @@ module.update_fn_metadata(hash, ["x: i64", "i64"]);
 
 // Register the module into the Engine as a static module namespace 'calc'
 let mut engine = Engine::new();
-engine.register_static_module("calc", module);
+engine.register_static_module("calc", module.into());
 
 engine.eval::<i64>("calc::inc(41)")? == 42; // refer to the 'Calc' module
 ```
 
-`Module::set_fn_XXX_mut` can expose functions (usually _methods_) in the module
-to the _global_ namespace, so [getters/setters] and [indexers] for [custom types] can work as expected.
+### Expose Functions to the Global Namespace
 
-[Type iterators], because of their special nature, are always exposed to the _global_ namespace.
+`Module::set_fn_mut` and `Module::set_fn_XXX_mut` can optionally expose functions (usually _methods_)
+in the module to the _global_ namespace, so [getters/setters] and [indexers] for [custom types]
+can work as expected.
+
+[Type iterators], because of their special nature, are _always_ exposed to the _global_ namespace.
 
 ```rust
 use rhai::{Engine, Module, FnNamespace};
@@ -93,15 +96,15 @@ module.update_fn_metadata(hash, ["x: &mut i64", "i64"]);
 
 // Register the module into the Engine as a static module namespace 'calc'
 let mut engine = Engine::new();
-engine.register_static_module("calc", module);
+engine.register_static_module("calc", module.into());
 
 // The method 'inc' works as expected because it is exposed to the global namespace
 engine.eval::<i64>("let x = 41; x.inc()")? == 42;
 ```
 
 
-Make the `Module` Dynamically Loadable
--------------------------------------
+Use Case 3 - Make the `Module` Dynamically Loadable
+--------------------------------------------------
 
 In order to dynamically load a custom module, there must be a [module resolver] which serves
 the module when loaded via `import` statements.