Implement parameterisable modules (#1800)

* first implementation

* remove done comment

* origin done

* impl log for instance

* impl inherent for instance

* Fix wasm build + full example build

this requires parity codec implements codec for core::marker::PhantomData

* patch parity-codec link to github branch

* improve internal names and fix instance prefix

* Fix in macros

* add test modules for support

this allow to test for construct_runtime as well.

The reason to have put that in another crate is:
* if we put test in `tests/` dir of srml/support then decl_storage fails to get
  srml-support access because it believes it is inside srml-support
  crate and so derive access to `quote!{ crate }` but this is wrong
  (and I don't see any way to prevent that, and it only bother us so I
  don't think that matters that much)
* if we put test inside lib.rs then contruct_runtime cannot be used
  because it call some macros that are defined with macros
  (decl_outer_event and decl_outer_origin) and thus rustc complains.

* defaultinstance to its own struct to avoid errors

* enforce <T, I> for Event and Config, impl test

* add origin, log, inherent to test

* test more code generation

* basic storage test

* fix typo

* rename a few imports and field

* delete wip test in example and runtime

* change default prefix to make it backward compatible with test

* rename Instance to I and Instantiable to Instance

note: the name of generic parameter I is only enforce by decl_module!
and this could be rewritten

* doc

* clean old TODOs

* update parity-codec to 3.2

* update node impl version + builds

* fix warning

* fix unrelated grandpa test

* refactor code

substrate/srml/support/src/lib.rs

@@ -64,6 +64,21 @@ pub use runtime_io::print;
 #[doc(inline)]
 pub use srml_support_procedural::decl_storage;
 
+pub mod lazy {
+	use spin::Once;
+
+	pub struct Lazy<T: Sync>(Once<T>);
+
+	impl <T: Sync> Lazy<T> {
+		pub const INIT: Self = Lazy(Once::INIT);
+
+		#[inline(always)]
+		pub fn get<F>(&'static self, builder: F) -> &T where F: FnOnce() -> T {
+			self.0.call_once(builder)
+		}
+	}
+}
+
 #[macro_export]
 macro_rules! fail {
 	( $y:expr ) => {{