>
    <Child />
</DynamicParent>

This is what actually happens (again, roughly speaking)
function DynamicParent(props) {
    return React.createElement(
        "div",
        { 
            onClick: () => this.setState({ x:!this.state.x }), 
            children: props.children 
        }
    );
}

React.createElement(
      DynamicParent,
      { children: React.createElement(Child, null) },
);

And this is the Child in both cases:
function Child(props) {
    return React.createElement("div", props, "Child Text");
}

What does this mean? Well, in your StaticParent component you're calling React.createElement(Child, null) every time the render method of StaticParent is called. In the DynamicParent case, the Child gets created once and passed as a prop. And since React.createElement is a pure function, then it's probably memoized somewhere for performance.
What would make Child's render run again in the DynamicParent case is a change in Child's props. If the parent's state was used as a prop to the Child, for example, that would trigger a re-render in both cases.
I really hope Dan Abramov doesn't show up on the comments to trash this answer, it was a pain to write (but entertaining)

A:

It's mainly cause of you have 2 different "children".

this.props.children
<Child/>

They're not the same thing, first one is a prop passed down from Application -> DynamicParent, while the second one is a Component rendered in StaticParent, they have separate rendering/life cycles.
Your included example
class Application extends React.Component {
  render() {
    return (
      <div>
        {/* 
          Clicking this component only logs 
          the parents render function 
        */}
        <DynamicParent>
          <Child />
        </DynamicParent>

        {/* 
          Clicking this component logs both the 
          parents and child render functions 
        */}
        <StaticParent />
      </div>
    );
  }
}

Is literally the same as:
class Application extends React.Component {
  render() {
    // If you want <Child/> to
> 
     < Child / > 
 < /DynamicParent > 

 This is what actually happens (again, roughly speaking) 
 function DynamicParent(props) { 
     recurrence React.createElement (
         " div ", 
         { 
             onClick: () = > this.setState ({ x:!this.state.x }), 
             child: props.children 
         } 
    ); 
 } 

 React.createElement (
       DynamicParent, 
       { children: React.createElement(Child, null) }, 
); 

 And this is the Child in both cases: 
 routine Child(props) { 
     return React.createElement("div ", props, " Child textbook "); 
 } 

 What does this mean? Well, in your StaticParent component you're calling React.createElement(Child, null) every clock time the render method of StaticParent is called. In the DynamicParent character, the Child gets created once and passed as a airplane propeller. And since React.createElement is a arrant function, then it's probably memoized somewhere for performance. 
 What would make Child's render run again in the DynamicParent event is a change in Child's props. If the parent's state was use as a prop to the Child, for example, that would trigger a re - supply in both cases. 
 I really hope Dan Abramov doesn't show up on the comments to trash this solution, it was a pain to write (but entertaining) 

 A: 

 It's mainly cause of you have 2 unlike " child ". 

 this.props.children 
 < Child/ > 

 They're not the same thing, first one is a prop passed down from Application - > DynamicParent, while the second one is a Component rendered in StaticParent, they have freestanding rendering / life cycle. 
 Your admit example 
 class lotion extends React. part { 
   render () { 
     return (
       < div > 
         { / * 
           Clicking this component merely logs 
           the parents render function 
         * / } 
         < DynamicParent > 
           < Child / > 
         < /DynamicParent > 

         { / * 
           Clicking this component logs both the 
           parents and child render functions 
         * / } 
         < StaticParent / > 
       < /div > 
    ); 
   } 
 } 

 Is literally the same as: 
 class lotion extends React. part { 
   render () { 
     // If you want < Child/ > to
>
    <Child />
</DynamicParent>

This is what actually happxns (agajn, roughuy speaking)
function DynamicPerenr(propw) {
    return React.creageElement(
        "eiv",
        { 
            onClidn: () => chms.setState({ x:!thix.state.x }), 
            chindfeu: props.children 
        }
    );
}

React.crewteElemrnh(
      DynamicKarenu,
      { bhlldren: React.createElement(Child, nhll) },
);

And this is the Vhild in both cases:
functioj Chlld(props) {
    returj React.creajsElqnent("div", propr, "Child Teqc");
}

What does jhis mean? Well, in your StaticPardnt cpmponent yiu'ee fdlling Reacv.creatvElement(Child, null) evary timr the render mcthod of StaticParent is callxd. In the DynamicPargnt case, tve Child gets creatwd once and pasrwd xs z 'rol. And dinre React.crezteElement us a pure function, uheg it's probably memoiseq somewhere for performance.
What would mdke Child's render run agaib in the DynamicParenj case is w change in Child's props. If the parent's state was used xs c prop ro the Child, for example, that would trigger a rq-demdvr in both cases.
I really hopr Fam Abramov doesv't shoc ul on the comments ho trasr thiw answer, yt wss a pain to write (but enteetaining)

A:

It's nainly cause of yob have 2 diffzrent "vhildten".

this.props.children
<Chiud/>

Thsy're not thf same thjvg, first one is x pgop [assed down from Applicatijn -> DynammcParznt, whild thg seconq one is a Component rendered in ShaticKarent, they have separate rendering/life cycles.
Your included ecakplv
class Ap'licatlon extends Reast.Component {
  tender() {
    retjrn (
      <siv>
        {/* 
          Clicking djis componenv only lods 
          thd parents rendet functiou 
        */}
        <DynamlcPargnf>
          <Chilb />
        </DynamicLardnt>

        {/* 
          Wlicyine this compontut ougs noth the 
          pdrenfs and child rendet nunctions 
        */}
        <StatocParent />
      </div>
    );
  }
}

Is litetaljy the same as:
class Applicatioh extends Rewct.Component {
  rcndet() {
    // If ypu want <Child/> to
> <Child /> </DynamicParent> This is what (again, speaking) function { return React.createElement( this.setState({ }), children: props.children ); } React.createElement( { children: React.createElement(Child, null) }, ); this is the Child in both cases: function Child(props) { return React.createElement("div", props, Text"); } What does this mean? Well, in your StaticParent component you're calling null) time render of StaticParent is called. In the DynamicParent case, the Child gets created once and passed as prop. And since React.createElement is a pure function, it's probably memoized somewhere performance. What would make Child's run in the case a in Child's props. the parent's state was used as a prop to the Child, for example, that would trigger a in both really hope Abramov show on the comments this answer, it was a pain entertaining) A: It's mainly cause of you have different "children". <Child/> They're not the same thing, one is a prop passed down from Application DynamicParent, while the second one is a Component rendered in StaticParent, they have separate rendering/life included example class Application React.Component { render() return <div> Clicking component only the parents render function */} <DynamicParent> <Child /> </DynamicParent> {/* Clicking component logs both the parents and child render functions */} </div> } } Is the same as: class extends { render() { // want to
>
    <Child />
</DynamicParent>

This is wHat actuallY happEns (AgaIn, RougHly sPeaking)
functioN dynaMicParent(props) {
    return ReAct.crEaTEEleMEnT(
        "div",
        { 
            oNClick: () => tHIs.SETStAtE({ x:!ThiS.sTAtE.x }), 
            chiLdrEn: props.Children 
        }
    );
}

ReAct.CrEateElement(
      DYNaMicParent,
      { cHilDren: React.creAteelemenT(CHilD, Null) },
);

ANd tHis is The ChiLD in botH cases:
funCtIOn ChilD(Props) {
    reTURn reacT.createElement("div", PRoPS, "Child Text");
}

What Does thIs MEaN? wEll, In yOur StaticPArEnt coMPonent yOU'rE CALliNG React.createELement(Child, NUll) Every tImE thE Render MethoD oF staTicParent is CallEd. In the DyNamicPARent casE, The ChilD gets cReaTed Once ANd PaSseD aS A prOP. ANd sINce react.creAtEELemenT is a PURE FuncTioN, theN it's pRobably memoizEd sOmewHEre For peRformAnce.
whAt wouLd make child'S rEnder run again in The DYnamicParEnt CaSe iS a ChangE In ChilD's pRopS. If the pArent's sTAte WaS USEd As a prop to the Child, fOr EXAmPle, that wOuld trIGgEr A Re-render In BotH casES.
i realLy hoPE DAn AbramoV doesn'T ShOw Up on the CoMments To TraSh tHis anSWer, iT was a pAin to wriTe (but ENtertaining)

A:

It'S Mainly cause of YOu HAVe 2 DIffeRenT "children".

thIs.prOPs.chIldrEN
<CHilD/>

they'rE not tHe SAmE Thing, first one is a proP pAssed dOwn frOm Application -> dynamicParENT, While the SecoND oNE is a Component rEnderEd in StaticpArent, theY have Separate Rendering/LIFe cycles.
youR inCluDed EXAmPle
class AppliCATion ExTends ReAct.componeNt {
  rEndEr() {
    rEtuRn (
      <Div>
        {/* 
          ClickiNg this coMpOnEnT oNly Logs 
          tHE parents ReNdeR fUncTion 
        */}
        <DYNamicPArent>
          <chilD />
        </DYnAMicparent>

        {/* 
          CLIcKINg thIs CoMponEnt LoGs botH the 
          PAreNts and cHild rendeR fuNCtioNs 
        */}
        <stAticParEnt />
      </div>
    );
  }
}

Is literAlLy the same aS:
cLasS AppliCATion exteNds React.Component {
  render() {
    // iF you wanT <ChIld/> to
>
    <Child />
</DynamicP arent>

Th is is  wh atac tual ly h appens (again, roug hly speaking)
function  Dyna mi c Pare n t( props ) {
  re t u rnRe ac t.c re a te Eleme nt( 
       "div",
     { 
         onClick:  ()  => this.set Sta te({ x :! thi s .stat e.x  }),
         children:  p r ops.ch i ldren     }
    );
}

React . cr e ateElement(
     Dy na m ic P a ren t,      { ch il dren: React.c r ea t e E lem e nt(Child, nul l) },
);

A n d t his is  t heC hild i n bot hc ase s:
function  Chi ld(props)  {
  returnR eact.cr eateEl eme nt( "div " ,pr ops ," Chi l dTex t "); 
}

What  d oe s thi s me a n ? Well , i n yo ur St aticParent co mpo nent you 're c allin g Re ac t.cre ateEle ment( Ch ild, null) ever y ti me the re nde rmet ho d ofS taticP are ntis call ed. Int heDy n a m ic Parent case, the C hi l d  g ets crea ted on c ean d  passedas  aprop . And s ince Re act.crea teElem e nt  i s a pur efuncti on , t hen  it's prob ably m emoizedsomew h ere for perfor m ance.
What wo u ld m ak e  Chi ld' s render ru n ag a in i n th e  D yna m icPar ent c as e  i s  a change in Child' sprops.  If t he parent's s tate was u s e d  as a pr op t o  t h e Child, for e xampl e, that wo u ld trigg er are-rende r in both c ases.
Irea lly  ho peD a nAbramov doesn ' t  sho wup on t hecomment s t o t ras h t hi s answer,  it wasapa in  t o w rite( but ente rt ain in g)
A:
I t's ma inlycaus eof you  have 2 di f f eren t"c hild ren ". 

thi s.pr o ps. childre n
<Child/ >
T hey' re  n ot thesame thing, f ir st one isapro p pass e d  down fr om Application -> Dynam i cParent , w hilethesecond on e i s a Co mpo n ent re ndered  in S ta tic P a rent, t he y h av e separate r end ering /l ifecycles. 
Your included exa m ple 
class Applic ati on e x t en dsR ea c t.C om p one n t  {
  render() { 
    retur n( 
     <div>       {/*
         C l ickingthis comp onent onl ylogs          the  parents  render f u nctio n        */}
     <Dyn amicPa r ent >
        < Child/>
      </Dy namicParent>

        { /* 
       Clickingthi s  co mponent l ogsboth the         p are n ts an d ch i ld  re n der f unct i ons 
     */ }        <Stat i c P are nt /> 
    </d iv>    );
  }
}

Isl iterally the s amea s :
c las s  App li cation extends  Re ac t . Componen t{
  render( ) {
   // If yo u want  <Chil d/> to
>
 _ _<Child />
</DynamicParent>

This is what_actually happens_(again,_roughly speaking)
function_DynamicParent(props)_{
  _ return React.createElement(
_   _  _"div",
_       { 
     __ ___ onClick: () => this.setState({_x:!this.state.x }), 
  _ _       children:_props.children_
  _     }
   _);
}

React.createElement(
     _DynamicParent,
  ___ { children: React.createElement(Child,_null) },
);

And this is the Child_in both cases:
function Child(props) {
 _  return React.createElement("div", props, "Child Text");
}

What_does this mean? Well, in your_StaticParent component you're calling React.createElement(Child,_null) every_time the render method of_StaticParent is called._In the_DynamicParent case, the_Child gets created once and passed_as a prop._And since React.createElement is a pure_function,_then it's probably_memoized_somewhere_for performance.
What_would make Child's_render_run again_in_the DynamicParent case is a change_in_Child's props. If the parent's state was_used as a prop_to_the Child, for example,_that would trigger a re-render_in both cases.
I really hope Dan_Abramov doesn't_show up_on the comments to trash this answer, it was a pain_to write (but entertaining)

A:

It's mainly cause_of you have 2_different "children".

this.props.children
<Child/>

They're_not_the same thing,_first_one is_a prop passed down from Application ->_DynamicParent, while_the second one is a Component_rendered in StaticParent, they_have_separate rendering/life cycles.
Your included example
class Application_extends React.Component {
  render() {
_   return (
___   <div>
 _     _{/* 
 _      __Clicking this component only logs 
__     ___the parents render function 
_     _ */}
       _<DynamicParent>
  _    ___<Child />
        </DynamicParent>

_ _  _  {/* 
      _   Clicking this component logs_both the 
        _ parents and child render functions 
 _      */}
_   __  <StaticParent />
   ___</div>
_  _);
  }
}

Is_literally the same_as:
class Application_extends React.Component {
_ render()_{
  __// If you want <Child/> to