Make tcp send OTP 26 compatible

Follow up of #7913
and #7921

This commit uses the approach explained in erlang/otp#7130 (comment)

We cannot use the macro `?OTP_RELEASE` since macros are evaluated at
compile time. RabbitMQ can be compiled with OTP 25 and executed with OTP
26. Therefore, we use `erlang:system_info(otp_release)` instead.
As `erlang:system_info/1` might be costly, we store the send function in
persistent_term.

For OTP 25, we use the "old tcp send workaround" (i.e.
`erlang:port_command/2`) which avoids expensive selective receives.
For OTP 26, we use `gen_tcp:send/2` which uses the optimised selective
receive.

Once the minimum required version becomes OTP 26, we can just switch to
`gen_tcp:send/2` and delete the `inet_reply` handling code in the various
RabbitMQ reader and writer processes.

Note that `rabbit_net:port_command/2` is not only used by RabbitMQ server,
but also by the AMQP 0.9.1 client.
Therefore, instead of putting the OTP version (or send function) into
persistent_term within the rabbit app, we just do it the first time
`rabbit_net:port_command/2` is invoked.
(`rabbit_common` is just a library without supervision hierarchy.)

(cherry picked from commit 6b4d881)

Author: ansd

deps/rabbit_common/src/rabbit_net.erl

@@ -168,7 +168,32 @@ port_command(Sock, Data) when ?IS_SSL(Sock) ->
         {error, Reason} -> erlang:error(Reason)
     end;
 port_command(Sock, Data) when is_port(Sock) ->
-    erlang:port_command(Sock, Data).
+    Fun = case persistent_term:get(rabbit_net_tcp_send, undefined) of
+              undefined ->
+                  Rel = list_to_integer(erlang:system_info(otp_release)),
+                  %% gen_tcp:send/2 does a selective receive of
+                  %% {inet_reply, Sock, Status[, CallerTag]}
+                  F = if Rel >= 26 ->
+                             %% Selective receive is optimised:
+                             %% https://github.com/erlang/otp/issues/6455
+                             fun gen_tcp_send/2;
+                         Rel < 26 ->
+                             %% Avoid costly selective receive.
+                             fun erlang:port_command/2
+                      end,
+                  ok = persistent_term:put(rabbit_net_tcp_send, F),
+                  F;
+              F ->
+                  F
+          end,
+    Fun(Sock, Data).
+
+gen_tcp_send(Sock, Data) ->
+    case gen_tcp:send(Sock, Data) of
+        ok -> self() ! {inet_reply, Sock, ok},
+              true;
+        {error, Reason} -> erlang:error(Reason)
+    end.
 
 getopts(Sock, Options) when ?IS_SSL(Sock) ->
     ssl:getopts(Sock, Options);