Reliable use_reducer dispatch and use_state setter

[futursolo]

Description

As described in #2112, use_state's value is susceptible to outdated values and causes the set_if_neq to be unreliable.

The reducer function is also susceptible to the same problem as it is tied to the dispatch function with the current implementation.

The value going stale problem mostly can be solved by adapting established patterns from the React world but it still requires the setter and dispatch function to work reliably (Or functions like their counterpart in React).

This PR takes a different approach which makes the reducer function to be static to avoid it becoming stale or attempting to pass a different reducer function between renders.
(Defining the reducer function outside of the component is a common practice in React and attempting to update another state while the component is rendering will result in an error in React.)

This PR consists of the following change:

• use_reducer now accepts 1 argument which is an initialiser function.
• The State of use_reducer now requires to implement Reducible trait which provides Action and reduce.
• Added use_reducer_eq which only re-renders if prev_state != next_state.
• use_state is implemented with use_reducer.
• Added use_state_eq which only re-renders if prev_state != next_state (Implemented with use_reducer_eq).
• UseStateHandle and UseReducerHandle only implements PartialEq if T: PartialEq.
• A set-only and dispatch-only handle can be detached from the original handle by calling the dispatcher and setter method. It always implements PartialEq even if T: !PartialEq. This can be passed as a prop / context if T is not PartialEq.

Fixes #2112 (in conjunction with #2125).

Checklist

• I have run cargo make pr-flow
• I have reviewed my own code
• I have added tests

[github-actions]

Visit the preview URL for this PR (updated for commit f800148):

https://yew-rs--pr2126-stale-value-ptcefc0e.web.app

_{(expires Thu, 18 Nov 2021 11:28:23 GMT)}

_{🔥 via Firebase Hosting GitHub Action 🌎}

[futursolo]

Old Approach:

struct CounterState {
    counter: i32,
}

let counter = use_reducer_with_init(
    |prev: std::rc::Rc<CounterState>, action: i32| CounterState {
        counter: prev.counter + action,
    },
    0,
    |initial: i32| CounterState {
        counter: initial + 10,
    },
);

New Approach:

struct CounterState {
    counter: i32,
}

impl Default for CounterState {
    fn default() -> Self {
        Self { counter: 10 }
    }
}

impl Reducible for CounterState {
    type Action = i32;

    fn reduce(self: Rc<Self>, action: Self::Action) -> Rc<Self> {
        Self {
            counter: self.counter + action,
        }
        .into()
    }
}

let counter = use_reducer(CounterState::default);

[voidpumpkin]

Looks good!

[siku2]

Just some documentation grammar