But is there ever a chance that these flags might change in the call to super.draw()
Generally, no. It's best practice to avoid calling invalidate() while the component is currently validating. Each call to invalidate() will cause the component to need to validate again. The core Feathers components never do that.
FeathersControl has a setInvalidationFlag() method that can set a flag without queuing up another validation. I try to avoid using it, but there are a few places where it is necessary.
I'm also guessing that this behaviour is affected by _ignoreChildChanges and _ignoreChildChangesButSetFlags
If a child dispatches Event.RESIZE outside of the validation cycle, the parent needs to update its layout. It calls invalidate() in the event listener.
The _ignoreChildChanges flag is for when the parent is currently validating, and it needs to resize a child as part of updating the layout. The component doesn't need to invalidate in this case because it should know what's happening already.
As long as you keep any code that changes children inside preLayout() and/or postLayout(), you shouldn't need to worry about this flag. Those methods exist so that you don't need to override draw().
_ignoreChildChangesButSetFlags is meant to keep a component from invalidating too frequently when it is subclassed and draw() is overridden. Any child changes before super.draw() will set flags but not cause another validation. This is one place where setInvalidationFlag() is used. It's mostly a hack to help people who don't know to set _ignoreChildChanges to help them avoid what could become an infinite validation loop. Regardless, if you stick to preLayout() and postLayout(), it won't affect you. Even if you override draw(), the flags are related to the layout, which the superclass handles.