Stop Watch class in C++ using chrono
Use clock's native resolution everywhere
If you cast time points and durations to something with a different resolution than that of clock, you risk losing precision. So for all internal state of your classes, I would definitely store everything as clock::duration and clock::time_point types. You might consider keeping the template parameter to ensure the return types of public member functions have the requested time resolution, but that just makes it easy for the caller to make the same mistake.
To give an example of where it can go wrong, suppose I write:
StopWatch&lt;std::chrono::seconds&gt; watch;
watch.go(); // done at 11:59:59.999
...
watch.stop(); // done at 12:00:00.000
auto elapsed = watch.elapsed_time();

With your implementation, elapsed will be equal to one second, even though only one millisecond passed.
If the issue is just convenience so the caller doesn't have to call std::chrono::duration_cast&lt;&gt;() themselves, I would remove the template parameter from the class, and make the member function elapsed_time() a template instead, like so:
template &lt;typename duration = clock::duration&gt;
duration elapsed_time() const noexcept
{
    ...
}

current_time() should not be constexpr
If you mark a function constexpr, you promise that this function can be evaluated at compile-time. But that does not make sense here.
Consider not storing lap results in LapWatch
Having struct Lap and a function to mark when a lap happened is good. However, by making lap() store the results in a member variable, you now gave LapWatch the responsibility to store laps. That might sometimes be exactly what you want, but maybe the caller wants to do something completely different. Maybe the previous laps don't need to be stored, or they need to be stored in a different way. I would make lap() return a Lap instead, and have the caller decide whether it wants to add those to some container. So:
Lap lap() {
    Lap current;
    ...
    return current;
}

And then the caller can write:
LapWatch&lt;&gt; watch;
std:vector&lt;Lap&gt; laps;
laps.push_back(watch.lap());

Use std::move() instead of static_cast&lt;Lap&amp;&amp;&gt;()
If you really want to move an object, use std::move(), it is shorter and less error-prone.
Note that neither the cast nor std::move() will do anything in this case, since neither Lap nor std::chrono::duration has a move constructor, but it doesn't hurt either.