You might want to look at some tutorial on references and pointers, as it is important to fully understand how memory is managed in order to avoid a lot of issues. Learning about std::shared_ptr is also going to be important when working with TGUI widgets, as Widget::Ptr is just a typedef for std::shared_ptr<Widget>.
Normally you have something like this. Both the window and gui are values stored on the stack. The tgui::Gui constructor takes a reference to the window as parameter, so although the code would be identical if it were to copy the window, nothing is copied when creating the gui.
sf::RenderWindow window(...);
tgui::Gui gui(window);
"&window" gives you a pointer to the window. This is not what the Gui constructor expects so you can't pass that. Although references are most likely implemented as pointers behind the scenes, references still act like objects in the code instead of as pointers. Pointers should actually be avoided when possible. The general rule is to use pointers when an object can be a nullptr (so for optional objects) and use references otherwise (or just copy them by value instead of referencing to the original object if it is something small like an int).
If your window is stored as a pointer then you need to dereference it. Notice the '*' in front of 'window'.
sf::RenderWindow &window;
tgui::Gui gui(*window);
So in your case, it would look like this:
tgui::Gui gui(*this->window);
I would actually advice against using a pointer for the window, the window is always going to be created with your Game, it is not something that can optionally exist. You will have to learn how to use the initializer list of the constructor (not to be confused with the completely unrelated std::initializer_list) in order to construct your window without using a pointer though.
Also, using "new" and "delete" is discouraged in modern c++. Smart pointers like std::unique_ptr and std::shared_ptr are the preferred way if you want to dynamically create objects.
void Game::initializeWindow()
In c++, using RAII is recommended over custom initialization functions. With your code, the Game object is in an invalid state between the moment it is constructed and the moment initializeWindow() is called. The principle of RAII is to put the code you have inside initializeWindow into the constructor of the Game object, so that it is in a valid state as soon as it is created and remains in a valid state for as long as the Game object exists (by not having a custom destroy function but putting cleanup code into the destructor).
It's a lot to process, but c++ isn't the most simple language to learn. And since TGUI quite heavily relies on modern c++, you might need to learn quite some things in order to properly use TGUI.