Add polymorphic shared_ptr port support (Issue #943)

Enable passing shared_ptr<Derived> to ports expecting shared_ptr<Base>
while preserving ABI and API compatibility.

Implementation:
- Add PolymorphicCastRegistry class for runtime cast registration
- Store registry in BehaviorTreeFactory via PImpl (ABI-safe)
- Propagate registry to blackboards via shared_ptr (tree outlives factory)
- Add polymorphic cast fallback in Blackboard::get() and TreeNode::getInputStamped()
- Add port type validation with polymorphic awareness in XML parser

API:
- factory.registerPolymorphicCast<Derived, Base>() to register relationships
- Supports transitive upcasts (Sphynx -> Cat -> Animal)
- Compile-time port type checking still catches invalid connections

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: facontidavide

include/behaviortree_cpp/blackboard.h

@@ -4,6 +4,7 @@
 #include "behaviortree_cpp/contrib/json.hpp"
 #include "behaviortree_cpp/exceptions.h"
 #include "behaviortree_cpp/utils/locked_reference.hpp"
+#include "behaviortree_cpp/utils/polymorphic_cast_registry.hpp"
 #include "behaviortree_cpp/utils/safe_any.hpp"
 
 #include <memory>
@@ -149,6 +150,25 @@ class Blackboard
 
   const Blackboard* rootBlackboard() const;
 
+  /**
+   * @brief Set the polymorphic cast registry for this blackboard.
+   *
+   * The registry enables polymorphic shared_ptr conversions during get().
+   * This is typically set automatically when creating trees via BehaviorTreeFactory.
+   */
+  void setPolymorphicCastRegistry(std::shared_ptr<PolymorphicCastRegistry> registry)
+  {
+    polymorphic_registry_ = std::move(registry);
+  }
+
+  /**
+   * @brief Get the polymorphic cast registry (may be null).
+   */
+  [[nodiscard]] const PolymorphicCastRegistry* polymorphicCastRegistry() const
+  {
+    return polymorphic_registry_.get();
+  }
+
 private:
   mutable std::mutex storage_mutex_;
   mutable std::recursive_mutex entry_mutex_;
@@ -159,6 +179,9 @@ class Blackboard
   std::shared_ptr<Entry> createEntryImpl(const std::string& key, const TypeInfo& info);
 
   bool autoremapping_ = false;
+
+  // Optional registry for polymorphic shared_ptr conversions
+  std::shared_ptr<PolymorphicCastRegistry> polymorphic_registry_;
 };
 
 /**
@@ -188,7 +211,28 @@ inline T Blackboard::get(const std::string& key) const
       throw RuntimeError("Blackboard::get() error. Entry [", key,
                          "] hasn't been initialized, yet");
     }
-    return any_ref.get()->cast<T>();
+    // Try direct cast first
+    auto result = any->tryCast<T>();
+    if(result)
+    {
+      return result.value();
+    }
+
+    // For shared_ptr types, try polymorphic cast via registry (Issue #943)
+    if constexpr(is_shared_ptr<T>::value)
+    {
+      if(polymorphic_registry_)
+      {
+        auto poly_result = any->tryCastWithRegistry<T>(*polymorphic_registry_);
+        if(poly_result)
+        {
+          return poly_result.value();
+        }
+      }
+    }
+
+    // If all casts failed, throw the original error
+    throw std::runtime_error(result.error());
   }
   throw RuntimeError("Blackboard::get() error. Missing key [", key, "]");
 }
@@ -325,12 +369,34 @@ inline bool Blackboard::get(const std::string& key, T& value) const
 {
   if(auto any_ref = getAnyLocked(key))
   {
-    if(any_ref.get()->empty())
+    const auto& any = any_ref.get();
+    if(any->empty())
     {
       return false;
     }
-    value = any_ref.get()->cast<T>();
-    return true;
+    // Try direct cast first
+    auto result = any->tryCast<T>();
+    if(result)
+    {
+      value = result.value();
+      return true;
+    }
+
+    // For shared_ptr types, try polymorphic cast via registry (Issue #943)
+    if constexpr(is_shared_ptr<T>::value)
+    {
+      if(polymorphic_registry_)
+      {
+        auto poly_result = any->tryCastWithRegistry<T>(*polymorphic_registry_);
+        if(poly_result)
+        {
+          value = poly_result.value();
+          return true;
+        }
+      }
+    }
+    // Cast failed
+    throw std::runtime_error(result.error());
   }
   return false;
 }

include/behaviortree_cpp/bt_factory.h

@@ -17,6 +17,7 @@
 #include "behaviortree_cpp/behavior_tree.h"
 #include "behaviortree_cpp/contrib/json.hpp"
 #include "behaviortree_cpp/contrib/magic_enum.hpp"
+#include "behaviortree_cpp/utils/polymorphic_cast_registry.hpp"
 
 #include <filesystem>
 #include <functional>
@@ -529,6 +530,45 @@ class BehaviorTreeFactory
   [[nodiscard]] const std::unordered_map<std::string, SubstitutionRule>&
   substitutionRules() const;
 
+  /**
+   * @brief Register a polymorphic cast relationship between Derived and Base types.
+   *
+   * This enables passing shared_ptr<Derived> to ports expecting shared_ptr<Base>
+   * without type mismatch errors. The relationship is automatically applied
+   * to all trees created from this factory.
+   *
+   * Example:
+   *   factory.registerPolymorphicCast<Cat, Animal>();
+   *   factory.registerPolymorphicCast<Sphynx, Cat>();
+   *
+   * @tparam Derived The derived class (must inherit from Base)
+   * @tparam Base The base class (must be polymorphic)
+   */
+  template <typename Derived, typename Base>
+  void registerPolymorphicCast()
+  {
+    polymorphicCastRegistry().registerCast<Derived, Base>();
+  }
+
+  /**
+   * @brief Access the polymorphic cast registry.
+   *
+   * The registry is shared with all trees created from this factory,
+   * allowing trees to outlive the factory while maintaining access
+   * to polymorphic cast relationships.
+   */
+  [[nodiscard]] PolymorphicCastRegistry& polymorphicCastRegistry();
+  [[nodiscard]] const PolymorphicCastRegistry& polymorphicCastRegistry() const;
+
+  /**
+   * @brief Get a shared pointer to the polymorphic cast registry.
+   *
+   * This allows trees and blackboards to hold a reference to the registry
+   * that outlives the factory.
+   */
+  [[nodiscard]] std::shared_ptr<PolymorphicCastRegistry>
+  polymorphicCastRegistryPtr() const;
+
 private:
   struct PImpl;
   std::unique_ptr<PImpl> _p;

include/behaviortree_cpp/tree_node.h

@@ -591,7 +591,35 @@ inline Expected<Timestamp> TreeNode::getInputStamped(const std::string& key,
         }
         else
         {
-          destination = any_value.cast<T>();
+          auto result = any_value.tryCast<T>();
+          if(result)
+          {
+            destination = result.value();
+          }
+          else if constexpr(is_shared_ptr<T>::value)
+          {
+            // Try polymorphic cast via registry (Issue #943)
+            if(auto* registry = config().blackboard->polymorphicCastRegistry())
+            {
+              auto poly_result = any_value.tryCastWithRegistry<T>(*registry);
+              if(poly_result)
+              {
+                destination = poly_result.value();
+              }
+              else
+              {
+                throw std::runtime_error(result.error());
+              }
+            }
+            else
+            {
+              throw std::runtime_error(result.error());
+            }
+          }
+          else
+          {
+            throw std::runtime_error(result.error());
+          }
         }
         return Timestamp{ entry->sequence_id, entry->stamp };
       }