@include-section should have the same load order as @section

If I have a main.scrbl, written:

@fn-a[]

@section{A section}
@fn-b[]

fn-a would be called first, and then fn-b.

However, if I extract the section to a file, so I have two files:

;;; main.scrbl
@fn-a[]

@include-section{section.scrbl}

;;; section.scrbl
@title{A section}
@fn-b[]

fn-b would be called first, and then fn-a.

However, they really should be called in the same order. In main.scrbl I might have something that modify a racket parameter (pinning the timezone in gregor, for example), and I would want those parameters get reflected in all sections.

I have a draft code that uses dynamic-require to solve this problem. However, I don't know whether it's general enough to be merged here:

(define (include-section* stx mod)
  (let* ([stx-path (syntax-source stx)]
         [mod-path (simplify-path (build-path stx-path 'up mod))])
    (dynamic-require `(file ,(path->string mod-path)) 'doc)))

(wrap-with-syntax include-section include-section*)

Where wrap-with-syntax is:

(define-syntax (wrap-with-syntax stx)
  (syntax-case stx ()
    [(_ name func)
     #'(define-syntax (name stx)
         (syntax-case stx () [(_ . t) #`(func (syntax #,stx) . t)]))]))

Compare the evaluation behavior of @section and @include-section using the main.scrbl and section.scrbl examples in the issue. Read the proposed dynamic-require implementation and wrap-with-syntax helper first; done means included sections observe parameter changes made earlier in the main document and preserve the same call order as inline sections.