Expression Parser Release [1x5]

- First release

- You can now include files with the import keyword, by simply using "" operator.
    Example:
      import "myfile.ep";
  
- Cleaned up some module code.

- Fixed a logical error inside of the optimizer. 
  (It optimized correctly, but after said optimization the cursor would be at the wrong position)
  
- Fixed bug in the engine constructor leading to undefined behaviour.

- Fixed fake conversion bug in ostream::put and ostream::putln. 
  (It would always throw a conversion error)

- Fixed another optmization bug where dead code optmization would only remove the first type of dead code.
  e.g:
    5 + 5;
    6 + 5;
  would optimize to:
    6 +5; 
  when really there should be no blocks left.

- Added plugins (aka import modules)
    Recommended usage:
        use function ep::load_plugins to load multiple plugins at once (e.g ep::module( ep::load_plugins( "v1", "v2" )))
        A plugin must contain the following functions:
            exern "C" __declspec(dllexport) void load_plugin( dispatch_engine_ptr );
            exern "C" __declspec(dllexport) const char *get_name( );
        
- FINALLY FIXED OPERATOR -> GLITCHES, YOU CAN NOW USE IT HOWEVER THE
  YOU DESIRE. FK YEA.

- Fixed another bug with the '->' operator
	Example:
		x()->y()->z()
	Wouldn't work, because the interpreter only considered
	value references from lvalue's, hence the above expression
	would be undefined behavour. (Would most like throw "invalid -> usage")
	
- Added the 'make_method' operator, it processes and makes a ep::method_ptr from a
  c++ callable.
  
- Added some C++ compile time error messages.
	
- Fixed a value reference bug:
	Previous to 1x5 the following C++ function:
		type *get_self_ptr( )
		{
			return this;
		};
		
		"get_self_ptr",
		[]( type *obj )
		{
			return std::make_shared<ep::value_reference>( obj->get_self_ptr( ),
				                                          engine->get_type_info( "" ) );
		};
	
	And if you then added that member method onto the type "type",
	and do this in ep:
		auto test = type(); // Construct..
		test->get_self_ptr(); // call...
		// Now 'test' has been destructed. Because
		// the rvalue of 'get_self_ptr' is destructed
		// at the end of the expression.
		
	which is why I added the possibilty to determine if a value_reference should be destructed,
	simply pass another argument to the constructor of value_reference of type bool,
	you only need to specify it if it's not supposed to be destructed, it is default true.
		"get_self_ptr",
		[]( type *obj )
		{
			return std::make_shared<ep::value_reference>( obj->get_self_ptr( ),
				                                          engine->get_type_info( "" ),
				                                          false ); // don't destruct.
		};