rabbit_deprecated_features: Use is_feature_used callback only if not required

[Why]
The `is_feature_used` callback is used to determine if a deprecated
feature can really be denied. Therefore it only makes sense for
deprecated features in their `permitted_by_default` and
`denied_by_default` phases.

When a deprecated feature enters the `disconnected` or `removed` phases,
the code being the feature should be gone. Therefore, there is no point
in checking if it is used.

[How]
We get the stability derived from the deprecated feature phase before we
actually run the callback.

While here, if the callback returns an error, we treat it as if it
returned that the feature is used.

As a reminder, a node will refuse to start if a deprecated feature is
denied but the feature is used. This is a slight change compared to the
initial goal of the deprecated features subsystem. Indeed, the goal was
to allow users experiment with the future behavior of RabbitMQ. However,
a future node would probably still start even if there were left-overs
from a removed feature. However if a `permitted_by_default` or
`denied_by_default` deprecated feature is denied, the node would refuse
to start. We see that as a strong way to communicate the user that an
action is required from them.

Author: dumbbell

deps/rabbit/src/rabbit_ff_controller.erl

@@ -1273,20 +1273,29 @@ list_feature_flags_enabled_somewhere(
       FeatureName :: rabbit_feature_flags:feature_name().
 
 list_deprecated_features_that_cant_be_denied(
-  #{states_per_node := StatesPerNode}) ->
+  #{feature_flags := FeatureFlags,
+    states_per_node := StatesPerNode}) ->
     ThisNode = node(),
     States = maps:get(ThisNode, StatesPerNode),
 
     maps:fold(
       fun
           (FeatureName, true, Acc) ->
-              #{ThisNode := IsUsed} = run_callback(
-                                        [ThisNode], FeatureName,
-                                        is_feature_used, #{}, infinity),
-              case IsUsed of
-                  true   -> [FeatureName | Acc];
-                  false  -> Acc;
-                  _Error -> Acc
+              FeatureProps = maps:get(FeatureName, FeatureFlags),
+              Stability = rabbit_feature_flags:get_stability(FeatureProps),
+              case Stability of
+                  required ->
+                      Acc;
+                  _ ->
+                      #{ThisNode := IsUsed} = run_callback(
+                                                [ThisNode], FeatureName,
+                                                is_feature_used, #{},
+                                                infinity),
+                      case IsUsed of
+                          true   -> [FeatureName | Acc];
+                          false  -> Acc;
+                          _Error -> [FeatureName | Acc]
+                      end
               end;
           (_FeatureName, false, Acc) ->
               Acc