Right approach for asynchronous TcpListener using async/await

The await task; in your Main won't compile; you'll have to use task.Wait(); if you want to block on it.

Also, you should use Task.Run instead of Task.Factory.StartNew in asynchronous programming.

Creating new Task does not necessarily mean new thread, but is this the right way?

You certainly can start up separate tasks (using Task.Run). Though you don't have to. You could just as easily call a separate async method to handle the individual socket connections.

There are a few problems with your actual socket handling, though. The Connected property is practically useless. You should always be continuously reading from a connected socket, even while you're writing to it. Also, you should be writing "keepalive" messages or have a timeout on your reads, so that you can detect half-open situations. I maintain a TCP/IP .NET FAQ that explains these common problems.

I really, strongly recommend that people do not write TCP/IP servers or clients. There are tons of pitfalls. It would be far better to self-host WebAPI and/or SignalR, if possible.

In order to stop a server accept loop gracefully, I register a callback that stops listening when the cancellationToken is cancelled (cancellationToken.Register(listener.Stop);).

This will throw a SocketException on await listener.AcceptTcpClientAsync(); that is easy to capture.

There is no need for Task.Run(HandleClient()), because calling an async method returns a task that is running in parallel.

    public async Task Run(CancellationToken cancellationToken)
    {
        TcpListener listener = new TcpListener(address, port);
        listener.Start();
        cancellationToken.Register(listener.Stop);
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                TcpClient client = await listener.AcceptTcpClientAsync();
                var clientTask = protocol.HandleClient(client, cancellationToken)
                    .ContinueWith(antecedent => client.Dispose())
                    .ContinueWith(antecedent => logger.LogInformation("Client disposed."));
            }
            catch (SocketException) when (cancellationToken.IsCancellationRequested)
            {
                logger.LogInformation("TcpListener stopped listening because cancellation was requested.");
            }
            catch (Exception ex)
            {
                logger.LogError(new EventId(), ex, $"Error handling client: {ex.Message}");
            }
        }
    }