does SORTPAIRS need to use reserve+emplace_back?

Nobody has claimed this yet.

I am working on the C++17 parallel version of SORTPAIRS, and I cannot use `emplace_back` there. I find that I can switch from `reserve` to `resize` and use simple assignment instead of `emplace_back`, but I don't know if this consistent with the intent.

Unfortunately, I don't see any non-RAJA parallel references to guide me here. The OMP and CUDA parallel versions just call `the RAJA::sort_pairs` method.

If it is allowed to use `resize+(assign)` instead, I'll make that change in the sequential implementation, independent of what I'm doing with C++ parallelism.

Thanks!

# old
```
vector_of_pairs.reserve(iend-ibegin);

std::for_each( //std::execution::par, // parallelism leads to incorrectness
begin,end,
[=,&vector_of_pairs](Index_type iemp) noexcept {
vector_of_pairs.emplace_back(x[iend*irep + iemp], i[iend*irep + iemp]);
});
```
# new
```
vector_of_pairs.resize(iend-ibegin);

std::for_each( std::execution::par,
begin,end,
[=,&vector_of_pairs](Index_type iemp) noexcept {
vector_of_pairs[iemp] = std::make_pair(x[iend*irep + iemp], i[iend*irep + iemp]);
});
```

Start by locating the sequential SORTPAIRS implementation and the RAJA::sort_pairs entry point. Compare the reserve+emplace_back and resize+assignment approaches with the C++17 parallel constraints described here, then determine whether the sequential implementation should adopt the alternative. Done means the intended approach is confirmed and the relevant implementation is consistent.

Written by the indexing model from the issue text.