What about allowing syntax sugar as an alternative to relying on the new
`from/Module` inline import idiom:
```
void fun(T)(std.stdio::File input, T value) if (std.traits::isIntegral!T)
{...}
```
instead of:
```
void fun(T)(Module!"std.stdio".File input, T value) if
(Module!"std.traits".isIntegral!T) {...}
```
Rationale:
* this reads much better (less noise); same as `=>` syntax for lambdas
* this is expected to be a very common pattern, so might as well make it as
simple as possible
* not particular on which symbol is used, could be something else, so long
it doesn't involve writing a string such as from!"std.traits". But :: will
be familiar to those coming from C++/rust etc.
* from!"" is too loose and can be abused arbitrarily:
```
// this compiles
void fun(){
from!"std.stdio; pragma(msg,`abuse...`); import std.stdio".File a;
}
```
Furthermore this is useful in other scenarios, namely when an import is
used only once in a context:
```
auto fun(){ return std.file::getcwd; }
```
is more DRY; instead of:
```
auto fun(){ static import std.file; return std.file.getcwd; }
auto fun(){ return Module!"std.file".getcwd; }
```
NOTE: if :: is not feasible for whatever reason, let's consider other
symbols without prejudice to this proposal.
