optional<const string &>::value_or returns reference to temp

I'm using `boost::optional` and found some pitfalls when using `value_or(char *)`.

Basically since `value_or` takes the "or" party as a template type the conversion from `char *` to `string` happens inside the function call and then a reference to that temporary is returned, leading to UB and in my case a crash.

Furthermore, even if the optional is populated and the alternative isn't use, it seems that some sort of copy of the value is still required because of the use of the `?:` and then a similar crash occurs.

I think a reasonable workaround would be to have the `value_or` for references take the alternative value (`r`) only as `const T &` instead of as a type param. This would require the implicit conversion to happen at the call site and the function would not create a temporary.

This doesn't avoid all possible dangling references but it improves things.

Here is a short reproduction. I'm using boost 1.69, gcc 8.2:
```c++
#include
#include
#include

int main()
{
const std::string input = "a good string";
boost::optional opt = input;

std::string output = opt.value_or("alternative"); // segfault here

std::cout << output << std::endl;
}
```

Note I do get a warning about returning a reference to a temporary. But usually we disable warnings within boost because there's so much noise.