create sorted vector of content of two binary search trees in sorted order

Design

If you are going to do this the C++ way then you should be using standard algorithms. A tree is a type of container; so you should be able to get an iterator to logically pass over each element in the container.

As a result I would expect the code to look like this:

    Tree    one;
    Tree    two;
    // Add data to one and two here.


    std::vector<int> result;
    result.reserve(one.size() + two.size());

    // There is a standard algorithm to combine two sorted containers.
    // So I would expect you to use that. Which means your
    // Tree structure should support an iterator concept.
    std::merge(std::begin(one), std::end(one),
               std::begin(two), std::end(two),
               std::back_inserter(result));

So looking at your code I see

struct Node
{
  Node* left;
  Node* right;
  int val;
};

What I would actually expect to see is:

class Tree
{
    struct Node
    {
        Node*   left;
        Node*   right;
        int     val;
    };
    class Iterator
    {
        public:
            using   value_type      = int;
            using   pointer         = int*;
            using   reference       = int&;
            using   difference_type = std::ptrdiff_t;
            using   iterator_category = std::forward_iterator_tag;

            Iterator();       // end()
            Iterator(Node*);  // begin()

            int const& operator*();
            Iterator operator++();
            Iterator operator++(int);

            bool operator==(Iterator const& rhs) const;
            bool operator!=(Iterator const& rhs) const;
    };
    Node*        root;
    std::size_t  size;

    public:
        Tree();
        void insert(int val);

        using iterator       = void;      // can't modify a BST
        using const_iterator = Iterator;

        const_iterator begin()  const {return Iterator(root);}
        const_iterator cbegin() const {return Iterator(root);}
        const_iterator end()    const {return Iterator();}
        const_iterator cend()   const {return Iterator();}

        bool         empty() const;
        std::size_t  size()  const;
};

Code Review

Now that I have shown what I would expect, let's have a look at what you wrote.

Don't use the using namespace X expression.

Doing this is bad practice. You are asking for trouble in the long run. For details see: Why is “using namespace std” considered bad practice?

using namespace std;

Even doing the below can be dangerous (though less than above). If you are going to do this don't do it at file scope: try and restrict the scope by doing it inside a function.

using boost::irange;
using boost::variant;

Both of these are bad habits. So, even for small projects, you should resist doing this. Habits are hard to break and you may do it accidentally when it actually matters.

The reason the "Standard" namespace is called "std" is so that the prefix std:: did not impose a large burden.

Constructor Using brace list

In this type of simple case:

struct Node
{
  Node(Node* l, Node* r, int v):left(l), right(r), val(v)
  {

  }
  Node* left;
  Node* right;
  int val;
};

You don't actually need to define a constructor. You can use brace initialization to initialize all the members (without needing a constructor).

Node x = new Node {nullptr, nullptr, 3};

User Defined Types

Its normal to use an initial capitol letter to define "User Defined Types" (while functions and variables have an initial lower case letter).

Now this is a common convention, but not universal (so you can take it or leave it). But using this convention does help. One of the big things about C++ is the type information. Being able to distinguish types from objects is really useful (so its a convention I follow).

typedef variant<Node*, int> stkElemT; // I would use StkElemT (see next rule)
typedef stack<stkElemT> bstStkT;      // I would use BstStkT  (see next rule)

Self Documenting Code

Writing self documenting code is critical to writing maintainable code. This basically means writing function and type names that explain exactly what they do.

typedef variant<Node*, int> stkElemT; // I would use StackElement
typedef stack<stkElemT> bstStkT;      // I would use SearchTreeStack

Comments

I actually like your comments (I usually hate people's comments). These are actually useful. So keep this up.

//from variant extract the pointer if valid otherwise NULL
struct stkElemVisitorNode : public boost::static_visitor<Node*>

//from variant extract the integer value if valid otherwise -1
struct stkElemVisitorInt : public boost::static_visitor<int>

//expand left most path of top node. 
void fillPathStkRecurse(bstStkT& bstStk)
{
}

BST and Balanced BST

A BST (binary search tree) does not need to be balanced. You go to extensive lengths to make sure the tree you build is balanced. I think this is overkill. A simple BST is easier to build.

Node* create_tree(vector<int>& vals, int start, int end) //end excluded

Begin/End

In C++ it is more traditional for the end iterator to be one past the end. Your code it marks the actual last element.

Its a valid choice. But not traditional C++ (so you should mention it in the comment. You try but I am not sure its clear). I would also encourage you to try it using the traditional method; in my opinion it will make the code easier.

Node* create_tree(vector<int>& vals, int start, int end) //end excluded

Prefer nullptr over NULL

    return new Node(NULL, NULL, vals[start]);

In C++11 we introduced nullptr which is a type safe NULL.