I've managed to find a workaround. Not sure if it's reliable, but better than nothing:

public static class NoesisBehaviorsFixes
{
/// <summary>
/// Fixes detaching behaviours when manipulating UI items.
/// </summary>
/// <remarks>
/// When a visual is removed from visual tree and this visual has an attached behaviours in it
/// (or its children) these behaviours gets a notification that they are removed from visual tree
/// and detach themselves, but adding them back to tree does not make them reattach.
/// This method remembers all objects that were detached and not reattached until returned object
/// is disposed and detaches them on dispose.
/// </remarks>
/// <returns></returns>
public static IDisposable GuardDetachingBehaviors()
{
return new AttachmentTracker();
}

    private class AttachmentTracker : IDisposable
    {
        private readonly HashSet<AttachableObject> objectsTodetach = new HashSet<AttachableObject>();
        private readonly PropertyMetadata metadata;
        private readonly PropertyChangedCallback originalChangeCallback;
        private bool isDisposed;

        public AttachmentTracker()
        {
            var type = typeof(AttachableObject);
            var field = type.GetField("AttachmentProperty", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
            var attachmentProperty = field.GetValue(null) as DependencyProperty;
            if (attachmentProperty == null)
            {
                isDisposed = true;
                return;
            }

            metadata = attachmentProperty.GetMetadata(typeof(AttachableObject));
            originalChangeCallback = metadata.PropertyChangedCallback;
            metadata.PropertyChangedCallback = OnAttachmentChanged;
        }

        public void Dispose()
        {
            if (!isDisposed)
            {
                DetachObjects();
                metadata.PropertyChangedCallback = originalChangeCallback;
                isDisposed = true;
            }
        }

        private void OnAttachmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if ((Visibility)e.NewValue == (Visibility)(-1))
            {
                if (d is AttachableObject obj)
                    objectsTodetach.Add(obj);
            }
            else
            {
                if (d is AttachableObject obj)
                    objectsTodetach.Remove(obj);
            }
        }

        private void DetachObjects()
        {
            foreach (var item in objectsTodetach)
                item.Detach();
        }
    }
}

Usage: any manipulation with UI elements that involves detaching them from visual tree should be guarded:

using (NoesisBehavioursFixes.GuardDetachingBehaviors())
{
... manipulate UI elements
}

This is the patch:

Index: AttachableObject.cs

--- AttachableObject.cs (revision 12128)
+++ AttachableObject.cs (revision 12129)
@@ -53,14 +53,10 @@
associatedObject.GetType(), GetType()));
}

• associatedObject.Destroyed += OnAssociatedObjectDestroyed;
  _associatedObject = GetPtr(associatedObject);
  _view = GetPtr(View.Find(this));

• BindingOperations.SetBinding(this, AttachmentProperty, new Binding("Visibility")

• {

• RelativeSource = new RelativeSource { AncestorType = typeof(UIElement) }

• });

•          InitObject();
  
           OnAttached();

  @@ -69,7 +65,7 @@

   public void Detach()
   {

• if (AssociatedObject != null)

• if (_associatedObject != IntPtr.Zero)
  {
  OnDetaching();

@@ -100,19 +96,9 @@
get { return (View)GetProxy(_view); }
}

• // We use a binding to get notified when the associated object is disconnected from the tree
• // and is going to be destroyed, so we can properly detach from it
• private static readonly DependencyProperty AttachmentProperty = DependencyProperty.Register(
• ".Attachment", typeof(Visibility), typeof(AttachableObject),
• new PropertyMetadata(Detached, OnAttachmentChanged));
• private static void OnAttachmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
• private void OnAssociatedObjectDestroyed(IntPtr d)
  {
• if ((Visibility)e.NewValue == Detached)
• {
• AttachableObject attachable = (AttachableObject)d;
• attachable.Detach();
• }

• Detach();
  }

   private const Visibility Detached = (Visibility)(-1);