Make the transform unaware of file extension magic.

The transformation rules for PSR-T do not need to be aware of extensions at all. The transformation can be as simple as A\B\C\D => src/C/D. By including extension in the transformation, it becomes something more complicated like (A\B\C\D, (E?)) => src/C/D(.E).

While this may seem natural for PSR-X to request Foo\Bar\Baz => src/Baz.php this seems to be an exception to the rule. For any other purpose, it actually becomes more complicated. While this *is* one of the reasons we wanted to extract some of the algorithm out of PSR-X, we left the extension handling to PSR-X itself and only required one piece of input... the fully qualified logical path of what you are looking for.

The idea is that PSR-X can be adjusted to indicate that the fully qualified class name must be mapped to a file using PSR-T by appending ".php" to the fully qualified class name. That's it! The transformation rules are identical, the only thing fancy about PSR-X is that that autoloader gets a logical name that needs an extension added to it.

> - The fully qualified class name MUST be mapped to a file name using transformation rules described by PSR-T by appending `.php` to the fully qualified class name as the logical path; the logical path separator MUST be a backslash."

If we make this change the transformation rules will become a lot more simple. The edge case of needing to add an extension can be handled on a case by case basis *by the user of the transformation* rather than requiring the transformation itself be aware of it or requiring every user of the transformation function to have to know whether or not they need to specify an extension.

### Impact on PSR-X implementations

For PSR-X specifically, it means going from this implementation:

```php
<?php
spl_autoload_register(function ($fqcn) {
    if ($file = transform($fqcn, "Foo\\Bar", "\\", "src", ".php")) {
        include $file;
    }
});
```

... to this implementation:

```php
<?php
spl_autoload_register(function ($fqcn) {
    if ($file = transform($fqcn.".php", "Foo\\Bar", "\\", "src")) {
        include $file;
    }
});
```

It is a relatively minor thing given that it will make a theoretical resource locator a lot more complicated. It is moving the ".php" extension bit from the fourth (optional) argument to appending it to the fqcn directly.

The data is all there anyway, but requiring the extension makes more work for everyone and the rules that much more complicated.

### Impact on PSR-T users

By needing to be aware of the extension, users of the transform function will have to break up their inputs. I'll admit this might be implementation specific (maybe a theoretical PSR-T user will naturally keep the resource path / extension separate) but I don't know that that will be the case. One or two *know uses*, however, don't make a distinction between extensions or not.

```php
<?php
public function findResource($name)
{
    $pathParts = pathinfo($name);
    $logicalPath = $pathParts['directory'].DIRECTORY_SEPARATOR.$pathParts['filename'];
    return transform($logicalPath, "Foo\\Bar", "\\", "src", $pathParts['extension']);
}
```

Compared to not having to worry about extensions:

```php
<?php
public function findResource($name)
{
    return transform($name, "Foo\\Bar", "\\", "src");
}
```

---

**TL;DR**

The transformation can be even more simple if you can guarantee that the extension (which is implementation specific as to whether or not it matters at all) is just included in the logical path to begin with. It flows more naturally (I'm not looking for (Foo\Bar\Baz, .php) or (A\B\C\D, .yml), I'm looking for Foo\Bar\Baz.php and A\B\C\D.yml) and makes the usage of the `transform` function easier.

Further, even without my patch, I can already do what I want (please verify this for yourself; it works on my machine with your current code):

```php
<?php
    public function testResourceName2()
    {
        $expect = "/path/to/foo-bar/config/Baz/Qux.yml";
        $actual = transform(
            ':Foo:Bar:Baz:Qux.yml',
            ':Foo:Bar',
            ':',
            '/path/to/foo-bar/config/'
        );
        $this->assertSame($expect, $actual);
    }
```

... which seems to make the whole extension thing pointless if nobody has to use it because it is already built into the transformation.

(this realization I just came to after writing all of this up, but it might be the best reason of all to remove extension from the rules...)