Taking &PathBufs is like taking &Strings, if you can't extend it because
it's not mutable, there's no use making sure it's on the heap. Taking
&Paths or &strs is simply more flexible to the caller without losing
anything for the procedure.

In the standard library, all code that wants to take an &Path takes
an impl AsRef<Path> instead, this way Strings and &strs can be passed
ergonomically. This commit uses &Path generally, because it may not be
worth the increase in binary size to add a generic. The author has no
preference one way or another and is open to rewriting to use the
alternative approach.

Resolves holochain#660

This change is valuable because you may obtain a path that
contains non-utf8 data and try to use it with these APIs,
but if these APIs take Strings, you have to lossily convert it
and you can't operate on those files.

The main non-obvious change as a result of this effort are changes like:

```
format!("using path: \'{}\'", some_string_path)
```
to
```
format!("using path: {:?}", some_pathbuf)
```

these result in a change from single quotes to double quotes.

The alternative substition is

```
format!("using path: \'{}\'", some_pathbuf.to_string_lossy())
```
this has the advantage of preserving single-quotes, but has the
disadvantage of requiring an extra allocation over the more
efficient Debug-impl of PathBuf.

There are existing instances in the code where the later approach is
used, it may be worth changing all instances to use the same choice.

I'm not sure how much of this was since last roundup and
how much I missed last time.

Note I only formatted the files I changed.
Did not a run full format in the name of keeping diff small.

Since an `&String` can be converted into an `&str` at zero-cost,
the reverse does not apply, and
having an `&String` gives you access to no more APIs than an `&str`,
this is an indisputable improvment.

At this point the only remaining occurences of `&String`
are to do with either `JsonString` or `EntryType`.
In a later PR I intend to address these warts.

Holy cow, there are so many occurences!
I gave up after removing many.