std::io: Add `Chars` iterator for Buffer.

Add `std::io::Chars` iterator and `Buffer#chars()` method
std: Add init and uninit to mem. Replace direct intrinsic usage
std: Add move_val_init to mem. Replace direct intrinsic usage
std: Move byteswap functions to mem
std: Make mem's doc slightly more accurate
mk: Replace 'compile_and_link' with 'oxidize'
Fixed a typo in list's find() documentation.
Make `if` and `while` conditions temporary

Closes #12033
Fix the signature of CreateSymbolicLinkW

Closes #12123
auto merge of #12120 : gifnksm/rust/buffered-chars, r=alexcrichton

Add `std::io::Chars` iterator and `Buffer#chars()` method
auto merge of #12124 : brson/rust/intrinsics, r=thestinger

As mentioned https://github.com/mozilla/rust/pull/11956#issuecomment-34561655 I've taken some of the most commonly-used intrinsics and put them in a more logical place, reduced the amount of code looking in `unstable::intrinsics`.

r? @thestinger
auto merge of #12126 : brson/rust/oxidize_mk, r=alexcrichton

I've always thought 'compile_and_link: ...' looked really awkward in our build output. Replace it with something more interesting. I'm open to alternatives to 'oxidize', like 'compile', anything but 'compile_and_link'.
std: Stop parameterizing some memcpy functions over RawPtr

It unsafe assumptions that any impl of RawPtr is for actual pointers,
that they can be copied by memcpy. Removing it is easy, so I don't
think it's solving a real problem.
std: Clean up the swap function a little
Rearranged enum section of tutorial for clarity.

This version starts with the simple case and builds on it.
auto merge of #12060 : chromatic/rust/enum_tutorial_improvement, r=alexcrichton

This version starts with the simplest case and builds on it. I believe it flows better.
auto merge of #12131 : brunoabinader/rust/list-find-doc-typo, r=alexcrichton

Replace ```v``` with ```ls```.
auto merge of #12134 : FlaPer87/rust/temporary-conditions, r=nikomatsakis

Closes #12033

IR Before:

```llvm
normal-return:                                    ; preds = %while_body
  %113 = load i64* %i
  %114 = sub i64 %113, 1
  store i64 %114, i64* %i
  br label %while_cond
```

IR After:

```llvm
normal-return:                                    ; preds = %while_cond
  store i8 %11, i8* %0
  %18 = load i8* %0, !range !0
  call void @_ZN9Temporary9glue_drop19he4ee51d3c03b9cf4ajE(%struct.Temporary* %10)
  %19 = bitcast %struct.Temporary* %10 to i8*
  call void @_ZN2rt11global_heap14exchange_free_19h4fabdf24a2250163aj4v0.0E(i8* %19)
  %20 = icmp ne i8 %18, 0
  br i1 %20, label %while_body, label %while_exit
```
auto merge of #12136 : alexcrichton/rust/issue-12123, r=brson

Closes #12123
auto merge of #12143 : brson/rust/swap, r=alexcrichton

Thinking about swap as an example of unsafe programming. This cleans it up a bit. It also removes type parametrization over `RawPtr` from the memcpy functions to make this compile.