RFC: conventions for placement of unsafe APIs

This is a *conventions RFC* for settling the location of `unsafe` APIs relative
to the types they work with, as well as the use of `raw` submodules.

The brief summary is:

* Unsafe APIs should be made into methods or static functions in the same cases
  that safe APIs would be.

* `raw` submodules should be used only to provide APIs directly on low-level
  representations.

[Rendered](https://github.com/aturon/rfcs/blob/unsafe-api-location/active/0000-unsafe-api-location.md)
One unlisted alternative is the design I gave in another issue (I forget where) that uses associated items (RFC PR #195) to provide e.g. `String::raw::from_parts()`. This solves the ergonomics of needing to import something to get access to the values. This would look like

```rust
impl String {
    /// Raw operations
    static raw: StringRaw = StringRaw;
}

struct StringRaw;

impl StringRaw {
    unsafe fn from_parts(buf: *mut u8, length: uint, capacity: uint) -> String;
    // ...
}
```

Personally, I think the ergonomics of this are nice. It's basically providing a tiny module structure for the static methods of a type, similar to how we use a module structure in general for types/functions. The biggest downside from a usability perspective is that it's not immediately obvious in rustdoc how this is supposed to be used.