Implementation of a generic thread-safe object wrapper
Correctness
foo can be destructed while another thread is performing an operation on it, because the destructor or its caller don't have to acquire a lock to do so. Technically destroying a mutex while it is locked already is undefined behavior, but it gets worse if another thread happens to modify the now invalid object.
Same reasoning for the move constructor: The object from which will be moved could still be modified concurrently by another thread, so locking would be required.
Also, rule of 3/5 violation: There's a custom move constructor (and there will hopefully be a corrected destructor), so copy constructor, move assignment operator and copy assignment operator should also be provided (currently, they copy without locking neither this nor the other object).
Also, m_mutex should be marked mutable, otherwise a const synchronized&lt;Foo&gt;&amp; can't be accessed.
Other nitpicks

In the second constructor, m should be moved.
object::object(T*, Mutex&amp;) should probably take it's first argument as T&amp; instead, as it should never be nullptr.
object as a name is very broad. Maybe change it to something more concise, like with_lock or locked_handle?

Suggestion
If targeting C++17 or later, consider providing a partial specialization for std::shared_mutex: const access paths only require a std::shared_lock(read only), while non-const access paths should be locked with std::unique_lock (write access). Also, for convenience, a as_const() member function to explicitly acquire a const reference would help. See this talk by Andrei Alexandrescu for more information on that topic.