Perform acks of any written buffers on poll

When data is enqueued and then sent to the socket with the send()
method, buffers are enqueued and then written as much as possible
into the socket, but the buffers are not yet acked. Prior to this commit,
the only place where written buffers were acked was inside the _sockIsWriteable()
method, invoked when the socket becomes writable. However, if
the socket remains non-writable, the data queue would fill with written-but-not-acked buffers. This in turn breaks the TX timeout
logic and causes the code to never signal a TX timeout to the application.
Fixed by adding ack code in the _sockPoll() method so all ack callbacks
are made from the "asyncTcpSock" task.

Author: avillacis

src/AsyncTCP.cpp

@@ -900,6 +900,20 @@ void AsyncClient::_sockPoll(void)
 {
     if (!connected()) return;
 
+    // The AsyncClient::send() call may be invoked from tasks other than "asyncTcpSock"
+    // and may have written buffers via _flushWriteQueue(), but the ack callbacks have
+    // not been called yet, nor buffers removed from the write queue. For consistency,
+    // written buffers are now acked here.
+    std::deque<notify_writebuf> notifylist;
+    int sent_errno = 0;
+    xSemaphoreTake(_write_mutex, (TickType_t)portMAX_DELAY);
+    if (_writeQueue.size() > 0) {
+        _collectNotifyWrittenBuffers(notifylist, sent_errno);
+    }
+    xSemaphoreGive(_write_mutex);
+
+    _notifyWrittenBuffers(notifylist, sent_errno);
+
     uint32_t now = millis();
 
     // ACK Timeout - simulated by write queue staleness