To be able to label incoming tor connections as different from normal localhost connections in e.g. `getpeerinfo` and the peers list in the GUI it'd be useful to have them connect on an alternative local-only port. Or even better, a UNIX socket.

For manually set-up hidden services this would have to be configured manually and could add a `hsport` option or such. The external port would still appear as `XXXXXXXXX.onion:8333`, however internally it would redirect to a that port.

In the case of `torcontrol` this would be easy to set up automatically. It could add a new (localhost) binding port automatically and this code would have to be changed:
- https://github.com/bitcoin/bitcoin/blob/master/src/torcontrol.cpp#L441
- https://github.com/bitcoin/bitcoin/blob/master/src/torcontrol.cpp#L477

    size_t nProcessQueueSize{0};
    RecursiveMutex cs_sendProcessing;
    std::deque<CInv> vRecvGetData;
    uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};
    std::atomic<int64_t> nLastSend{0};
    std::atomic<int64_t> nLastRecv{0};
    const int64_t nTimeConnected;
    std::atomic<int64_t> nTimeOffset{0};
    // 
    const CAddress addr;
    // 
    const CAddress addrBind;
    std::atomic<int> nVersion{0};
    RecursiveMutex cs_SubVer;
    /**
     * cleanSubVer is a sanitized string of the user agent byte array we read
     * from the wire. This cleaned string can safely be logged or displayed.
     */
    std::string cleanSubVer GUARDED_BY(cs_SubVer){};
    bool m_prefer_evict{false}; // 
    bool HasPermission(NetPermissionFlags permission) const {
        return NetPermissions::HasFlag(m_permissionFlags, permission);
    }
    // 
    bool m_legacyWhitelisted{false};
    bool fClient{false}; // 
    bool m_limited_node{false}; //
    std::atomic_bool fSuccessfullyConnected{false};
    // 
    // 
    std::atomic_bool fDisconnect{false};
    bool fSentAddr{false};
    CSemaphoreGrant grantOutbound;
    std::atomic<int> nRefCount{0};
    const uint64_t nKeyedNetGroup;
    std::atomic_bool fPauseRecv{false};
    std::atomic_bool fPauseSend{false};
    bool IsOutboundOrBlockRelayConn() const {
        switch (m_conn_type) {
            case ConnectionType::OUTBOUND_FULL_RELAY:
            case ConnectionType::BLOCK_RELAY:
                return true;
            case ConnectionType::INBOUND:
            case ConnectionType::MANUAL:
            case ConnectionType::ADDR_FETCH:
            case ConnectionType::FEELER:
                return false;
        } // 
        assert(false);
    }
    bool IsFullOutboundConn() const {
        return m_conn_type == ConnectionType::OUTBOUND_FULL_RELAY;
    }
    bool IsManualConn() const {
        return m_conn_type == ConnectionType::MANUAL;
    }
    bool IsBlockOnlyConn() const {
        return m_conn_type == ConnectionTyp