The largest issues here involve head of line blocking, both for QUIC and for HTTP/2.
Yes, TCP does a great job of achieving line rate, when properly tuned. If all you want to do is download/upload a large file, TCP will saturate your 10 gigabit network connection just fine once you replace congestion control with something a little bit less loss sensitive like BBR.
The problem is that for usecases like downloading a web page, you have two head of line blocking issues:
1. In HTTP/1.1, pipelining lets you have multiple requests on a single connection, but the server has to respond to them in order. That means a server can't respond to the second or third request promptly if the first is large or takes a long time to process at the server. HTTP/2 fixes this. That ultimately makes things easier for both web clients and servers that care about performance, given a robust HTTP/2 implementation. The alternative is to have a bunch of parallel connections, which is both more resource intensive and is less friendly with respect to congestion control, and unless you never pipeline at all you can still get unlucky.
2. TCP being a single stream is more sensitive to single packet drops, which is inefficient when you logically have several streams. If your higher level abstraction is multiple independent streams (as with HTTP/2) switching from TCP to a multi-stream transport protocol like QUIC (or e.g. SCTP) packet less has less latency impact because it only affects the streams where the packet loss occurs rather than blocking all streams.
Note that neither of these makes a difference if all you're trying to do is download a single large file. They *do* make a difference if you're downloading a 2 GB file and then decide, on the same connection, that you want to fetch a 1 KB piece of metadata.
Lastly, I don't think the centralization argument holds a lot of water. There are plenty of sources of complexity in implementing a web browser or web server. If protocol complexity is significant, presumably you use one of a number of existing well tested implementations rather than rolling it yourself.