add in a default file hash and cleaned up init function a bit

> forces the caller to make a conscious decision to ignore shutdown. Much safer practice than depending on the programmer to call defer Close() at all call sites.

I agree that is a nice property. An approach like:

```Go
unlock := lock.Lock()
doSomethingCritical()
unlock()
```
Might avoid making mistakes a bit more. But note it doesn't actually force the user to deal with the return value.

```Go
lock.Lock()
doSomethingCritical
// oops
```
doesn't even get a warning.

---

The added complexity and leaking of abstractions is that if `cancel` its not going to be called in the same function than you have to continue leaking it out, or add it to a new object:

```Go
// you have to carry around an additional cancel _everywhere_ you pass n.
// now prone to programming and design error.
// the function is now state you're passing around. hiding it in a callstack does not change that.
func constructNode() ipfs.IPFS, context.CancelFunc {
  cfg := ....
  ...
  ...
  n, cancel := ipfs.NewNode(...)
  ...
  ...
  ...
  return n, cancel 
}

// or what will invariably happen:

type nodeCtx struct {
  node ipfs.IPFS
  cancel context.CancelFunc
}


func constructNode() nodeCtx {
  cfg := ....
  ...
  ...
  n, cancel := ipfs.NewNode(...)
  ...
  ...
  ...
  return nodeCtx{node: n, cancel: cancel}
}
```

I dont think passing these cancel functions around is a good idea. I'd be curious to see what go-nuts have to say about it.

---

This is not critical. Let's keep it in mind and move on.