Moving Facade::$app to Application::$Current

I really like the Facades construct, because it simplifies a call to a singleton, static instance of a Class.

I moved the Facade::$app to
```php

class Application extends Container implements HttpKernelInterface {

	/**
	 * Singleton instance
	 */
	protected static $Current = null;

	/**
	 * Facade function, get singleton of Application
	 */
	public static function getCurrent() {    
		return static::$Current;
	}

	public static function setCurrent($newCurrent) {
		$current = static::$Current;
		
		if ($newCurrent !== null) {
			// Force this to be only in testing environment?
			static::$Current = $newCurrent;
		}
		
		return $current;
	}

	// ...	

	/**
	 * Create a new Illuminate application instance.
	 *
	 * @return void
	 */
	public function __construct()
	{
		// Auto push master Application
		if (static::getCurrent() == null) static::setCurrent($this);

		// ...
```
The getCurrent() function is also the heart of the new Facade class. Using the explicit getCurrent function, Facades and real Singletons are streamlined in usage:
App::getCurrent() returns Application::getCurrent(), and that returns the protected Application::$Current variable. 
Because App extends Facade, Facade will __callStatic any method on the App::getCurrent (= Application::getCurrent) instance.
```php
namespace Illuminate\Support\Facades;

abstract class Facade {
	
	/**
	 * Facade function for a Singleton, or registered component
	 */
	public static function getCurrent() {
		throw new \RuntimeException("Facade does not implement static getCurrent method.");
	}
	
	/**
	 * Handle dynamic, static calls to the Current() object.
	 *
	 * @param  string  $method
	 * @param  array   $args
	 * @return mixed
	 */
	public static function __callStatic($method, $args)
	{
		return call_user_func_array(array(static::getCurrent(), $method), $args);
	}
}
```

Now for example, in the \Illuminate\Support\Facades\Router class you see, that the functions become direct aliases:

```php
class Route extends Facade {

	// ...

	/**
	 * Determine if the current route uses a given controller action.
	 *
	 * @param  string  $action
	 * @return bool
	 */
	public static function uses($action)
	{
		return static::currentRouteUses($action);
	// instead of
	//	return static::$app->currentRouteUses($action);
	}

	/**
	 * Get the registered component 'router'.
	 *
	 * @return \Illuminate\Routing\Router
	 */
	public static function getCurrent() {
		return \Illuminate\Foundation\Application::getCurrent()['router'];
	}
}
```

This change touches one line in helpers.php, instead of
```php
	return \Illuminate\Support\Facades\Facade::getFacadeApplication();
```
it is now
```php
	return \Illuminate\Foundation\Application::getCurrent(); 
```
And in start.php the following lines are removed:
```php
Facade::clearResolvedInstances();
Facade::setFacadeApplication($app);
```

The Support\Facade classes are now absolutely independent from the rest of the framework.

```php
        // same methods tied down:
	Application::getCurrent()['router']->currentRouteUses()
	// is
	App::getCurrent()['router']->currentRouteUses()
	// is
	Route::getCurrent()->currentRouteUses()
	// is
	Route::currentRouteUses()
	// is
	Route::uses()
```