Let's have a look at your updated code:

Constructors

Point(int a, int b) :
    x(a),
    y(b)
{};

Point(const Point &p) :
    x(std::move(p.x)),
    y(std::move(p.y))
{};

The first one is fine, although I would generally mark the inputs a and b as const. However, given that they are basic integers it doesn't matter too much.

However, what is troubling is you mangling of a copy constructor with move semantics. You can only have one. When you pass p as a const reference you cannot move its values, as that would change them, So you have to write one copy constructor and one move constructor. For the copy constructor you can delegate to the explicit one:

Point(const Point &p) : Point(p.x, p.y) {};

For more complex classes, look into the copy and swap idiom which makes life much more easier .

Member access

Avoid the usage of this-> in your code. The only moment you have to use it is when you have name collisions. You should never have name collisions, so you should never need this->.

Operators

Regarding your less-than operator:

bool operator<(const Point& rhs) const
{
    if (x != rhs.x)
    {
        return x < rhs.x;
    }
    else
    {
        return y < rhs.y;
    }
}

It is more of a personal preference, but I generally prefer ternary operators in such situations:

bool operator<(const Point& rhs) const
{
    return (x == rhs.x) ? y < rhs.y
                        : x < rhs.x;
}

Globals

Global constants are sometimes a necessary evil. But most certainly not here. Create a class and put matrix and friends as members in it.

Avoid one-liner

You have a lot of multi-line statements in a single line

    if (new_pos.x < 0 || new_pos.x > matrix.size() - 1) continue;
    if (new_pos.y < 0 || new_pos.y > matrix[0].size() - 1) continue;

This is really bad practice that will haunt you later on. It takes so much more time to read code, when you cannot be sure whether something is a long conditional or already the body of the if/for/while.

Avoid copying everything

In your find_next_match(std::string input, Point cur_pos) function you are copying the string every time you call it. What is even worse, is that you copy it and then force a complete reshuffle of the memory via input.erase(0,1). This is completely unneeded. Just pass the string as a const reference and a size_t as the current position you are in the string.

Even better, when you refactor that into a class, you can make the string a member and omit it from the argument list.

Another way

Personally I find the solution rather boring. It is the same as a million other problems out there. For the sake of originality, I would propose to use a graph representation of the matrix to traverse it.

So every element of the matrix is a node with up to four edges, which connect it with its neighbors. Then you can simply traverse the the graph in a depth-first search to find the string.

Regarding EDIT2

I would definitely make the directions member a static member, so that you do not have to pass it to the constructor. It is never changing, so there is no need for it to be initialized by the constructor.

The index check should better be a greater-or-equal; this is clearer. Also you should return false, as the word was not found.

    if (index >= input.size())
    {
        return false;
    }