Allow a slightly wider class of constants to be inlined

[Keno]

Currently we only inline constants (i.e. replace Const() yielding
statements by the constants themselves) if the constant in question
is isbits. We do this to avoid blowing up the size of the IR by
inlining constants that are too large. However, there are some
useful small constants that this definition ignores. E.g. I
was working with structs of the form:

struct Dims
    d::NTuple{N, Int} where N
end

and the IR was littered with various pure statements that the
optimizer wouldn't inline because this struct isn't considered
isbits (side-note, I want to change that, but that's a separate
issue). Here I'm proposing changing the criteria for a struct
to be eligible for inlining slightly: Rather than just looking
for isbits, we recurse through any immutable, isbits fields and
as long as the size of all structs combined isn't too large, we
allow the inlining.

[vtjnash]

Need to check if the x.i field isdefined before loading it

[Keno]

whoops, thanks

[maleadt]

This broke the following code from LLVM.jl:

function callme(ir, fn, args::Expr=:())
    quote
        Base.@_inline_meta
        Base.llvmcall(($ir,$fn), Nothing, Tuple{}, $args...)
    end
end

@generated function main()
    ir = """
        define void @entry() #0 {
        entry:
          ret void
        }"""
    fn = "entry"

    return callme(ir, fn)
end

isinteractive() || main()

ERROR: LoadError: error statically evaluating llvm IR argument

I can work around it by doing $(args.args...), but it may be an unintended side-effect of this PR.