Store Object Refactoring

[KazaiMazai]

• Public StoreObject is marked as deprecated (only renaming required)
• Moved actual StoreObject the Store internals.
• Updated docs
• Updated tests

This change allows to:

• Keep a strong reference to the StoreNode and control its state lifecycle by doing that
• Obtain a weak reference store when needed to guarantee any possibility of creating ref cycles
• Do both things with just Store

This:

extension StoreNode {
    func store() -> Store<State, Action> {
        Store(dispatch: { [weak self] in self?.dispatch($0) },
              subscribe: { [weak self] in self?.subscribe(observer: $0) }
        )
    }

    func referencedStore() -> Store<State, Action> {
        Store.referencedStore(dispatch: { [self] in self.dispatch($0) },
                              subscribe: { [self] in self.subscribe(observer: $0) }
        )
    }
}

and this:

extension Store {
    func store() -> Store<State, Action> {
        switch storeType {
        case .storeObject(let referencedStore):
            return referencedStore.weakRefStore()
        case .store:
            return self
        }
    }
    
    static func referencedStore(dispatch: @escaping Dispatch,
                                subscribe: @escaping Subscribe) -> Store {
        
        Store(
            .storeObject(StoreObject(
                dispatch: dispatch,
                subscribe: subscribe)
            )
        )
    }
}