Q:

C++: Optimizations made on wrapped methods that are trivial

When I write wrapper classes, a lot of the methods take the following form:
class Wrapper{
    public:
        vec3 getPos(){          return m_position.get();  }
        void setPos(vec3 pos){  m_position.set(pos);      }
    private:
        ThingGettingWrapped m_position;
    }
}

I was curious however, will getPos() and setPos() incur overhead, or are modern compilers smart enough to optimize the delegation away so wrapper.set/get() is equivalent to wrapper.m_thingWrapped.set/get()?   
(I know the methods are inlined in my example, but assume they are not explicitly inlined and defined separately)

A:

An optimizer can expand the call inline in which case there is no overhead for the extra call. 
A wrapper like that can incur overhead if the call is not expanded inline. 
Optimizers of modern compilers do inline expansion. 

assume they are not explicitly inlined and defined separately

There will be (small) overhead unless the optimizer can expand the call inline.  You can guarantee the ability to inline by calling the function in the same translation unit where it was defined.  Defining the function inline - like you did in your example - enables and enforces this for all translation units because inline functions are defined in all of them.  Another way to allow inline expansion across translation units is LTO. 
A function is not required to be inline in order for it to be expandable inline and an optimizer is not required to inline-expand all calls to inline functions.  A function that is inline will always be expandable inline.  A function that is not inline may be expandable in some case, but not always.