`MvxNotifyPropertyChanged.RaisePropertyChanged` does not affect `BindableProperty`
## 💬 Questions and Help

I get stuck in some strange issue.

I use `BindableProperty` to create custom `MvxContentView`. Only class that I create does not working correctly.

Is there problem with the way I using `RaiseAllPropertiesChanged`?

## CustomView

```
    public partial class TextView : MvxContentView<IViewModel>
    {
        public static readonly BindableProperty TextProperty =
            BindableProperty.Create(
                propertyName: nameof(Text),
                returnType: typeof(string),
                declaringType: typeof(TextView),
                defaultValue: string.Empty,
                propertyChanged: OnTextChanged);

        private static void OnTextChanged(BindableObject bindable, object oldValue, object newValue)
        {
            var textView = (TextView)bindable;
            // Works fine! if I change text, this code executed as I expected.
        }

        public string Text
        {
            get => (string)GetValue(TextProperty);
            set => SetValue(TextProperty, value);
        }

        public static readonly BindableProperty TextSizeProperty =
            BindableProperty.Create(
                propertyName: nameof(Unit),
                returnType: typeof(Unit),
                declaringType: typeof(TextView),
                defaultValue: new Unit(16, "Hello, World!"),
                propertyChanged: OnTextSizeChanged);

        private static void OnTextSizeChanged(BindableObject bindable, object oldValue, object newValue)
        {
            var textView = (TextView)bindable;
           // Never executed! even if I change text size, this code does not executed.
        }
        public Unit TextSize
        {
            get => (Unit)GetValue(TextSizeProperty);
            set => SetValue(TextSizeProperty, value);
        }
```

## Unit
Here is `Unit` class that I bind to CustomView.

```
    public class Unit : MvxNotifyPropertyChanged
    {
        protected float _value;

        public Unit(float value)
        {
            _value = value;
        }

        public float Value
        {
            get => _value;
            set
            {
                _value = value;
                RaiseAllPropertiesChanged();
            }
        }
    }
```
as you can see `Unit` class is simple.

## Model
And here is `Model` class, which has `Unit` and other properties.

```
    public class Model : MvxNotifyPropertyChanged
    {
        private Unit _textSize;
        private string _text;

        public Model(Unit textSize, string text)
        {
            _textSize = textSize;
           
            // the reason why I listen to `PropertyChanged` is `Unit.Value` can be changed by others.
            _textSize.PropertyChanged += (sender, e) =>
            {
                RaiseAllPropertiesChanged();
            };
            _text = text;
        }

        public string Text
        {
            get => _text;
            set => SetProperty(ref _text, value);
        }

        public Unit TextSize
        {
            get => _textSize;
            set => SetProperty(ref _textSize, value);
        }
    }
```

## ViewModel
And here is my `ViewModel` class.
```
    public class ViewModel : MvxViewModel<Model>
    {
        public ViewModel () { }

        private Model _model;
        public Model Model 
        {
            get => _model;
            set => SetProperty(ref _model, value, () =>
            {
                _model.PropertyChanged += (sender, e) => 
                {
                    RaiseAllPropertiesChanged();
                };
            });
        }

        public string Text
        {
            get => _model.Text;
            set => _model.Text = value;
        }

        public Unit TextSize
        {
            get => _model.TextSize;
            set => _model.TextSize = value;
        }
    }
```
