Dependency Container
Before addressing the main question, I would like to compare two of the primary methods: register and get. The register method is written well in terms of returning early.

  public static function register($name, $class) {
        $reflection = new ReflectionClass($class);
        if (!$reflection-&gt;isInstantiable()) {
            throw new Exception('The provided class is not instantiable: ' . $class);
        }
        if (!in_array($name, self::$classes)) {
            self::$classes[$name] = $class;
        }
        self::$lastRegistered = $name;
        return __CLASS__;
    }


With this method the indentation is kept to a single level. Because of this it is simple to read.
The get method could be re-worked to decrease indentation levels.

  public static function get($name = NULL)   {
          $name = (!$name) ? self::$lastRegistered : $name;
          if (self::$classes[$name]) {
              if (self::$instances[$name]) {
                  return self::$instances[$name];
              } else {
                  self::$instances[$name] = new self::$classes[$name];
                  return self::$instances[$name];
              }
          } else {
              throw new Exception('The following class name could not be found: ' . $name);
          }
      }


The ternary operator with null check can be simplified using a null coalescing operator:
 $name = $name ?? self::$lastRegistered;

And with PHP 7.4+ the null coalescing assignment operator is available:
  $name ??= self::$lastRegistered;

By returning early there is need for else - this can decrease indentation levels, which can result in ones that aren’t as long, as well as make the method shorter over-all:
public static function get($name = NULL) {
    $name = $name ?? self::$lastRegistered;
    if (!self::$classes[$name]) {
        throw new Exception('The following class name could not be found: ' . $name);
    }
    if (self::$instances[$name]) {
        return self::$instances[$name];
    }
    self::$instances[$name] = new self::$classes[$name];
    return self::$instances[$name];
}

In addition to requiring fewer lines of code, there is also no need for the else keyword.

How is this called ? Singleton ? Container ? Dependency injection ?

This appears to be a variation of the Singleton pattern. Typically a singleton class would have a private constructor and a static method like getInstance() that would return a static property after conditionally assigning that property to a newly instantiated object if it hadn’t been set.