Inconsistent Code Style

Choose one coding style and use it. Some tips:
PascalCasing can be used for class/type names, but especially for template parameters.
camelCasing is mostly Java-style and fits for methods and variables (especially local vars).
c_uses_underscores almost for everything except template parameters (you can see it everywhere).
Choose what you wan't, some use CMyClass and TMyTemplate (Microsoft MFC/ATL Style), but once you choose one, use it everywhere - don't mix it.

Accessibility (what is public, private or protected)

You can use struct (all public) for your test code, but if you want to become good programmer, think about what should be public, private or protected (the last is for derived classes). I would start like this:

/// Binary Search Tree (note: this is Doxygen style documentation comment)
template<class T> class bstree { // bintree, BinarySearchTree, C/TBinTree... as you choose
    struct node { // private as first things in class are private for a good reason
        node *left, *right; // you can split it to two lines and comment like following:
        T value;   ///< node value (again, Doxygen will generate documentation from this)
    }; // no need for a constructor, it is our private struct (or protected if you like)
    node *root;    ///< root node (I prefer data first in class to see what we use)
    size_t count;  ///< nodes is not a good name, count, size, number...
public: // now is the time to show what we can do

Now I will clear it of those comments:

/// Binary Search Tree
template<class T> class bstree {
    struct node {
        node *left;   ///< left node (if any)
        node *right;  ///< right node (if any)
        T value;      ///< stored value
    };
    node *root;       ///< root node
    size_t count;     ///< total number of nodes in the tree
public:
    bstree(): root(nullptr), count(0) {}

Doxygen will be able to generate nice documentation for you if you get used to those /// comments before and ///< comments after.

I think that node should be either private or protected, because you present data storage, not the nodes. You can use T or name it ValueType, but I prefer T for single template parameter - it is obvious what it is.

(note: some prefer not to use protected at all, I disagree: helpers private, interface public, usable internals as protected for further sub-classing and enhancements. Makes sense for non-virtual classes/templates as well when we want to create new container with new/different features and new data for the features - e.g. fast lookup for last searched node, or flat_set from vector. I have reworded the last sentence a bit - see comments below. In short: don't inherit publicly, use private/protected base when there is a public non-virtual destructor.)

Copy/Move and Default Constructors + operator =

You should understand lvalue and rvalue references first. If you don't know what && is good for (std::move, std::forward), stick with const T& const reference for a while. BTW: I have seen T const& pattern in your code - I prefer const T& because it shows what is const (the value, not the reference - like const T* means cannot change the value pointed to, not cannot change the pointer), but it is your style, use it if you wish.

bstree();              ///< default constructor
bstree(const bstree&); ///< copy constructor (preserve what is passed)
bstree(bstree&&);      ///< move constructor (may destroy/clear what is passed)
bstree& operator = (const bstree&); ///< copy assignment
bstree& operator = (bstree&&);      ///< move assignment
bstree& operator = (bstree);        ///< wrong! would make a copy first, then like bstree&&

edit note: The last can be used in copy-and-swap idiom as pointed out by rudus, but there was no move constructor. Another link about that topic here.

Move will destroy the right side, swapping makes no sense (edit: now I see the intent - leave the destruction on the swallowed rvalue). But beware not to call rhs.clear() because that could dispose the nodes:

/// move assignment
    bstree& operator = (bstree&& rhs) {
        if(&rhs == this)    // we better check
            return *this;   // not to dispose our nodes
        clear();            // dispose ours first
        root = rhs.root;    // 'steal' the nodes
        count = rhs.count;  // get the count
        rhs.root = nullptr; // clear the other
        rhs.count = 0;      // and count it
        return *this;       // this comes last
    }

Errors

remove: uninitialized parent - what about removing the last node?
...I am finished, unless you rewrite it and comment, what is what, what and how it should do it ;)

Have a nice day :) I hope I was not too harsh :)

Addendum

All those nice upvotes encouraged me, to rethink the design a bit. Here is my (incomplete) code on IdeOne.com using std::unique_ptr.

Constructors, copy and move

/// Default constructor for empty tree
    bstree(): root(), count(0) {}
//note: no need for a destructor, we use managed pointers
//  ~bstree() {}
/// Copy constructor
    bstree(const bstree& src)
    : root(src.root->copy()), count(src.count) {}
/// Move constructor
    bstree(bstree&& rhs)
    : root(std::move(rhs.root)), count(rhs.count) {
        rhs.count = 0; }
/// Move assignment
    bstree& operator = (bstree&& rhs) {
        root.swap(rhs.root);
        std::swap(count, rhs.count);
        return *this; }
/// Copy assignment
    bstree& operator = (const bstree& rhs) {
        if (this != &rhs) {// no self-copy
            root.reset(rhs.root->copy());
            count = rhs.count; }
        return *this; }

Few methods

bool contains(const T& value) {
    return root && root->find(value); }
bool insert(const T& value) {
    ptr* where = &root;
    if(root) {
        where = root->where(value);
        if(!where) return false; }
    where->reset(new node(value));
    ++count; return true;
}

Core

/// Binary Search Tree
template<class T> class bstree {
// I will make use of protected, feel free to use private only
// ... can be used to create another template
// ... or for debug purposes - printouts in such derived class
// ... but remember to never inherit publicly
// ... because it has public non-virtual destructor
//================================================================== node
protected:
    struct node;    // forward declaration
    typedef std::unique_ptr<node>
        ptr;        ///< managed pointer to node
    struct node {
        ptr left;   ///< left node (if any)
        ptr right;  ///< right node (if any)
        T value;    ///< stored value
    //------------------------------------------------ node: construction
        node() {}
        node(
          const T& value,
          node* left = nullptr,
          node* right = nullptr)
        : left(left), right(right), value(value) {}
        node(
          T&& value,
          node* left = nullptr,
          node* right = nullptr)
        : left(left), right(right), value(value) {}
    //--------------------------------------------------- node: deep copy
    /// Make a deep copy of all nodes. May be called on null as well.
        node* copy() {
            return !this ? nullptr :
              new node(value,
              left->copy(),
              right->copy());
        }
    //-------------------------------------------------- node: find value
    /// Find node with specified value. May be called on null as well.
        node* find(const T& what) {
            node* it = this;
            while(it) {
                if(what < value)
                    it = it->left.get();
                else if(value < what)
                    it = it->right.get();
                else break;
            }
            return it;
        }
    //------------------------------------------------- node: place value
    /// Find place for new node \return null if already there
        ptr* where(const T& what) {
            node* it = this;
            ptr* where;
            for(;;) {
                if(what < it->value) {
                    if(!it->left) return &it->left;
                    it = it->left.get();
                } else if(it->value < what) {
                    if(!it->right) return &it->right;
                    it = it->right.get();
                } else return nullptr;
            }
        }
    };
//================================================================== data
protected:
    ptr root;       ///< root node
    size_t count;   ///< total number of nodes
//====================================================== ctor, copy, move
public:
/// Default constructor for empty tree
    bstree(): root(), count(0) {}
//note: no need for a destructor, we use managed pointers
//  ~bstree() {}
/// Copy constructor
    bstree(const bstree& src)
    : root(src.root->copy()), count(src.count) {}
/// Move constructor
    bstree(bstree&& rhs)
    : root(std::move(rhs.root)), count(rhs.count) {
        rhs.count = 0; }
/// Move assignment
    bstree& operator = (bstree&& rhs) {
        root.swap(rhs.root);
        std::swap(count, rhs.count);
        return *this; }
/// Copy assignment
    bstree& operator = (const bstree& rhs) {
        if (this != &rhs) {// no self-copy
            root.reset(rhs.root->copy());
            count = rhs.count; }
        return *this; }
//=============================================================== methods
public:
    bool contains(const T& value) {
        return root && root->find(value); }
    bool insert(const T& value) {
        ptr* where = &root;
        if(root) {
            where = root->where(value);
            if(!where) return false; }
        where->reset(new node(value));
        ++count; return true;
    }
    bool insert(T&& value) {
        ptr* where = &root;
        if(root) {
            where = root->where(value);
            if(!where) return false; }
        where->reset(new node(value));
        ++count; return true;
    }
};

...feel free to comment if you find some bug :)