Logger

This PR is the first effort to integrate logging into the Sia codebase. A new logger has been constructed and cautiously deployed. Thus far, I have mainly used it to replace calls to `panic()`. A more thorough inspection of the codebase is necessary to determine what sort of logging operation is appropriate for each circumstance.

The details of the logger are outlined in issue #226, but I will paraphrase them here.
- A logger field has been added to each of the Participant, Engine, and State objects.
- For now, everything uses the "Default" logger, which outputs to stderr.
- Logging operations should be carried out as far up the call chain as possible.
- The new `ctxError` type can be used to construct errors with context.
- Logger initialization is not yet complete.

To use the logger, call the `Log()` method for maximum control, or one of the predefined options such as `Error()` or `Fatal()`. These are in the style of `fmt.Println()`, so you can call them like `p.log.Warn("wallet", wid, "could not be properly initialized:", err)`.

To use `ctxError`s, you can either create a new error with `sialog.Error()` or extend an error using `sialog.AddCtx()`. Each call to `AddCtx()` adds another context entry to the error. When the error is printed, the contexts are displayed in order. Example:

```go
func foo() error {
    return sialog.Error("kernel panic")
}

func bar() {
    err := foo()
    err = sialog.AddCtx(err, "could not complete due to error in foo")
    sialog.Error(err)
}
```
The output would look something like:
```
[15:23:12] ERROR:
    bar: could not complete due to error in foo
    foo: kernel panic
```

The result is similar to a stack trace (which can be generated with `sialog.Trace()`). I'm thinking about merging the two, or at least reusing some functionality.

One important thing that's missing is tests. Testing a logger isn't a straightforward task. I think the stdlib uses regexes to do it.

The logger is far from polished, and I'm sure it will continue to grow and become more useful as it becomes more integrated into the codebase. There are certainly many design decisions that need to be agreed upon. But the initial results are promising. When used properly in conjunction with `ctxError`, the new logger can tell you exactly who called a function, when they called it, and why it failed. I think we'll be very happy to have it when debugging a complex project like Sia.