LogLevel [was std.experimental.logger formal review round 3]

[Martin Nowak via Digitalmars-d]

I just found a very compelling alternative solution to the LogLevel 
disabling problem. This was one of the reasons for the delay of std.log 
and the current solution still isn't great [1].

This idea here achieves
- fine grained control over log levels (per module/package)
- zero overhead for statically disabled log levels
- zero (almost) boilerplate (works even with the global stdlog)
- and it establishes a nice convention to enable logging for a library
   `pkg.logLevel = LogLevel.info;`

Basically it works by declaring a logLevel in a module or package.
Then the std.logger module does a reverse lookup of that declaration.

```d
module mymod;

import std.logger;

// can be anything that converts to a LogLevel
// calls with lower log level can be optimized away if this is a compile 
time constant
// runtime values also work nicely but incur a small overhead
// if this declaration is not present, logLevel from the package is used 
or the default LogLevel.

enum logLevel = LogLevel.critical;

void foo()
{
     info("information from foo"); // optimized out
     fatal("error");               // logs
}
```

https://gist.github.com/MartinNowak/443f11aa017d14007c35

There is a tiny gotcha, this works because the logger module imports the 
calling module. So we'd need to avoid module constructors in the logger 
module or use a workaround [2].

Also it can lead to additional imports when the whole package is 
imported to resolve logLevel.  This can be avoided though by declaring 
logLevel in a separate module and making it available in every module of 
a package.

```d
module mypkg.loglevel;

LogLevel logLevel;
```
```d
module mypkg.foo.bar;

public import mypkg.logLevel;

void baz(T)(T t)
{
     info("baz");
}
```

[1]: http://forum.dlang.org/post/m2p3r6$148j$1@digitalmars.com
[2]: 
https://github.com/D-Programming-Language/phobos/blob/9a46840c2b36beb6711244ec4340c117fc91a0f1/std/stdiobase.d