Elide the temporary container created when returning from algorithms

When we write something like

``` c++
auto xs = make_tuple(...);
auto ys = transform(xs, f);
```

A temporary tuple is created and then move-assigned to `ys`. This should be elided most of the time, but providing a way to make sure that this is always the case (without relying on the optimizer) would be nice. This can be achieved e.g. by providing mutating algorithms:

``` c++
auto xs = make_tuple(...);
Result ys;

length(xs).times.with_index([&](auto i) {
ys[i] = f(xs[i]);
});
```

There are probably other ways to achieve this too. See the [original discussion](http://thread.gmane.org/gmane.comp.lib.boost.devel/261077/focus=261308) on the Boost.Devel mailing list.

Review the existing algorithm entry points and the linked Boost.Devel discussion first; the issue does not identify files or tests. Compare the proposed mutating algorithms with other approaches, then define the accepted API and establish coverage showing that returning from algorithms does not require the temporary container.

Written by the indexing model from the issue text.