Make TakeExactly!R implicitly convertible to Take!R

Many container methods accept `Take!Range` but not the result of `takeExactly`. This patch makes the latter implicitly convertible to the former, seamlessly allowing for code like this:
```d
void main()
{
	import std.algorithm : equal, findSplitBefore;
	import std.container.slist;
	import std.range : only, takeExactly;

	auto list = make!SList(1, 2, 3, 4);
	auto split = list[].findSplitBefore(only(3));
	list.linearRemove(split[0]); // Currently an error, OK with this patch
	assert(list[].equal([3, 4]));
}
```
std.algorithm.commonPrefix and the `findSplit*` functions all document that they return the same type as `takeExactly` does on the same input.

However, while the `Take!Range` idiom is commonly supported among containers, it's not a formal part of those primitives, so I didn't add any documentation in this patch explaining this capability. It's just a nice extra until we formalize the `Take!Range` idiom or figure out something better to replace it.

It's debatable whether it's justified to use it here as `Take` is defined in the same module, but it's the convention used so that if the super-type (`Take!R` in this case) has a member of the same name, this one doesn't shadow it. These kind of *AliasThis* getters have to be public or the conversion will fail. IIRC, the convention was first introduced in TDPL. It's used in std.typecons for the getters `_Tuple_super` and `Scoped_payload`. I think the single underscore prefix is the better way (and IIRC the one used in TDPL), I simply forgot it here.