You have missed the point of async/await
It wasn't created to frustrate developers with deadlocks. It was created to free up Processing power while we wait for a non CPU based task to complete.
The lack of synchronisation context in dotnetcore might save you from unexpected deadlocks, but it also means you have to worry about thread starvation.
Everytime you block a thread with task.Wait() or task.Result() thats one less Thread that your app could be using to do stuff with.
Using await frees up that Thread to be used on other tasks.
Where you would have got a deadlock before, you now run out of threads.
I'm going to risk a thought experiment to demonstrate the point without actually testing the code. Always a risk because things are never as simple as they seem.
Let's say we have an ecommerce site. customer places orders via an api call to the backend. the api saves the order to a database, but some orders need fraud checking via an external api which is sometimes v slow, say 60sec.
During normal operation you get a couple of orders a minute and the site operates fine. During your christmas sale however you get an order per second.
You are running on a 4 core machine, if your API blocks on the fraud check you are down to 3 threads, if another 3 fraud check orders come in before the first completes the orders start queuing up. The API is locked.
A slow order completes and frees up a thread, but now you have a backlog of requests to catch up with and each one of those requests has a timeout.
So at peak times customers starts seeing "Error could not place order : timeout"
If you await the fraud call instead then the thread is immediately freed up when the call is made and can be servicing requests until the response comes back. You only have 1 order a second and 4 threads are plenty.