Made '__stdloggermutex' shared between threads, so it can fulfill its purpose.
Abstract methods have to be marked 'abstract', or the compiler wont complain about missing implementations, but instead assume they will be in some .o file that is later passed to the linker.
Made reads/writes to globalLogLevel atomic and separated global log level from stdlog's log level.
(Had to add a cast to the first array element of LogLevel arrays in foreach(). Possibly a compiler bug in 2.066 master.)
Avoid races with reading/writing the standard Logger:
 * User code can no longer directly read out the stdlog, because by the time it has the reference, it might already be obsolete. (Later an `opApply` style function could be provided to execute functions/delegates in the context of a locked stdlog.)
 * The stdlog property was split up into a public setter `stdlog` and a package getter `stdlogImpl`, because the compiler doesn't like different visibility for getter and setter.
 * All module level functions dealing with the stdlog now synchronize with the global `__stdloggermutex`.
static assert(__ctfe) doesn't do what one might expect. Code is always generated and emitted for `isLoggingActive` and it can be called at runtime. This commit turns the template function into just a template `isLoggingActiveAt` and a global bool flag `isLoggingActive`, so they can both be evaluated without parenthesis now and don't end up as functions in the final executable.
Fix: Unittesting symbols like randomString() are visible outside of the logger package.
Changed Logger methods to `final`, that are not documented as overridable to gain more control over the implementation details when I implement thread safety measures.
Made `fatalHandler` accessible as a property to allow synchronization in later commits.
Also made `writeLogMsg` protected, so it can assume it is properly synchronized already by the public calls calling it.
To log a pre-built message `forwardMsg` can now be used. (See `FileLogger`).
Fixed my mistake, where setting `stdlog` before querying `stdlogImpl` would revert the setting. And while I was at it, I changed `stdlog`s behavoir on assignment of `null`: It will now put the default logger back in place.
First attempt on making logging thread safe: Logger now has a mutex to protect its public API.
The module level functions don't perform any runtime checks themselves to avoid races.
Instead the logger does all checking under protection of its mutex.
`globalLogLevel` will be evaluated only once for any public logging call and thus needs no global locking.
All overrides of `writeLogMsg`, `beginLogMsg`, `logMsgPart` and `finishLogMsg` have `protected` visibility now, since they expect their logger to be already under mutex protection and must not be publically visible.
Fixed `MultiLogger` to not perform checks for its children to avoid races.
Small fix for `StdLoggerDisableLogging`.