Fix non trivial exit processing

exit events where sometimes called 2 times due to the fact that they
always returned false.
This was always triggering process_internal_generic_event in
include/boost/sml/back/state_machine.hpp line 190.

Change implementation to have a behavior similar to the on_entry events
but with reversed logic, bottom to top instead of top to bottom

include/boost/sml.hpp

@@ -856,18 +856,8 @@ template <class T>
 struct transitions<T> {
   template <class TEvent, class SM, class TDeps, class TSubs>
   static bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
-    return execute_impl(event, sm, deps, subs, current_state);
-  }
-  template <class TEvent, class SM, class TDeps, class TSubs>
-  static bool execute_impl(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
     return aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{});
   }
-  template <class _, class TEvent, class SM, class TDeps, class TSubs>
-  static bool execute_impl(const on_exit<_, TEvent> &event, SM &sm, TDeps &deps, TSubs &subs,
-                           typename SM::state_t &current_state) {
-    aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{});
-    return false;
-  }
 };
 template <>
 struct transitions<aux::true_type> {
@@ -910,6 +900,13 @@ struct transitions_sub<sm<TSM>, T, Ts...> {
     sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
     return true;
   }
+  template <class _, class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute_impl(const back::on_exit<_, TEvent> &event, SM &sm, TDeps &deps, TSubs &subs,
+                           typename SM::state_t &current_state) {
+    sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
+    transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+    return true;
+  }
 };
 template <class TSM>
 struct transitions_sub<sm<TSM>> {

include/boost/sml/back/transitions.hpp

@@ -39,20 +39,8 @@ template <class T>
 struct transitions<T> {
   template <class TEvent, class SM, class TDeps, class TSubs>
   static bool execute(const TEvent& event, SM& sm, TDeps& deps, TSubs& subs, typename SM::state_t& current_state) {
-    return execute_impl(event, sm, deps, subs, current_state);
-  }
-
-  template <class TEvent, class SM, class TDeps, class TSubs>
-  static bool execute_impl(const TEvent& event, SM& sm, TDeps& deps, TSubs& subs, typename SM::state_t& current_state) {
     return aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{});
   }
-
-  template <class _, class TEvent, class SM, class TDeps, class TSubs>
-  static bool execute_impl(const on_exit<_, TEvent>& event, SM& sm, TDeps& deps, TSubs& subs,
-                           typename SM::state_t& current_state) {
-    aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{});
-    return false;  // from bottom to top
-  }
 };
 
 template <>
@@ -102,6 +90,14 @@ struct transitions_sub<sm<TSM>, T, Ts...> {
     sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
     return true;  // from top to bottom
   }
+
+  template <class _, class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute_impl(const back::on_exit<_, TEvent>& event, SM& sm, TDeps& deps, TSubs& subs,
+                           typename SM::state_t& current_state) {
+    sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
+    transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+    return true;  // from bottom to top
+  }
 };
 
 /// @brief Event executor on a sub state machine without transition in parent state machine.